Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / d4daf59dcff1a07a7949b2aaa01c7735ecb6dc43 / . / glave-generate.py
blob: 2cbc54486423601d54af1a90db8708efddff0641 [file] [log] [blame]
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1#!/usr/bin/env python3
2#
3# XGL
4#
5# Copyright (C) 2014 LunarG, Inc.
6#
7# Permission is hereby granted, free of charge, to any person obtaining a
8# copy of this software and associated documentation files (the "Software"),
9# to deal in the Software without restriction, including without limitation
10# the rights to use, copy, modify, merge, publish, distribute, sublicense,
11# and/or sell copies of the Software, and to permit persons to whom the
12# Software is furnished to do so, subject to the following conditions:
13#
14# The above copyright notice and this permission notice shall be included
15# in all copies or substantial portions of the Software.
16#
17# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23# DEALINGS IN THE SOFTWARE.
24#
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]25
26import sys
27
28import xgl
29
30class Subcommand(object):
31 def __init__(self, argv):
32 self.argv = argv
Chia-I Wuec30dcb2015-01-01 08:46:31 +0800[diff] [blame]33 self.headers = xgl.headers
34 self.protos = xgl.protos
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]35
36 def run(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]37 print(self.generate())
38
39 def generate(self):
40 copyright = self.generate_copyright()
41 header = self.generate_header()
42 body = self.generate_body()
43 footer = self.generate_footer()
44
45 contents = []
46 if copyright:
47 contents.append(copyright)
48 if header:
49 contents.append(header)
50 if body:
51 contents.append(body)
52 if footer:
53 contents.append(footer)
54
55 return "\n\n".join(contents)
56
57 def generate_copyright(self):
58 return """/* THIS FILE IS GENERATED. DO NOT EDIT. */
59
60/*
61 * XGL
62 *
63 * Copyright (C) 2014 LunarG, Inc.
64 *
65 * Permission is hereby granted, free of charge, to any person obtaining a
66 * copy of this software and associated documentation files (the "Software"),
67 * to deal in the Software without restriction, including without limitation
68 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
69 * and/or sell copies of the Software, and to permit persons to whom the
70 * Software is furnished to do so, subject to the following conditions:
71 *
72 * The above copyright notice and this permission notice shall be included
73 * in all copies or substantial portions of the Software.
74 *
75 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
76 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
77 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
78 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
79 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
80 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
81 * DEALINGS IN THE SOFTWARE.
82 */"""
83
84 def generate_header(self):
85 return "\n".join(["#include <" + h + ">" for h in self.headers])
86
87 def generate_body(self):
88 pass
89
90 def generate_footer(self):
91 pass
92
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]93 # Return set of printf '%' qualifier, input to that qualifier, and any dereference
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]94 def _get_printf_params(self, xgl_type, name, output_param):
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]95 deref = ""
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]96 # TODO : Need ENUM and STRUCT checks here
97 if "_TYPE" in xgl_type: # TODO : This should be generic ENUM check
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]98 return ("%s", "string_%s(%s)" % (xgl_type.replace('const ', '').strip('*'), name), deref)
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]99 if "char*" == xgl_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]100 return ("%s", name, "*")
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]101 if "uint64_t" in xgl_type:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]102 if '*' in xgl_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]103 return ("%lu", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
104 return ("%lu", name, deref)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]105 if "size_t" in xgl_type:
Chia-I Wu54ed0792014-12-27 14:14:50 +0800[diff] [blame]106 if '*' in xgl_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]107 return ("%zu", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
108 return ("%zu", name, deref)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]109 if "float" in xgl_type:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]110 if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]111 return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name), deref)
112 return ("%f", name, deref)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]113 if "bool" in xgl_type or 'xcb_randr_crtc_t' in xgl_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]114 return ("%u", name, deref)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]115 if True in [t in xgl_type for t in ["int", "FLAGS", "MASK", "xcb_window_t"]]:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]116 if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]117 return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name), deref)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]118 if '*' in xgl_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]119 return ("%i", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
120 return ("%i", name, deref)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]121 if output_param:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]122 return ("%p", "(void*)%s" % name, deref)
123 return ("%p", "(void*)(%s)" % name, deref)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]124
125 def _generate_trace_func_ptrs(self):
126 func_ptrs = []
127 func_ptrs.append('// Pointers to real functions and declarations of hooked functions')
128 func_ptrs.append('#ifdef WIN32')
129 func_ptrs.append('extern INIT_ONCE gInitOnce;')
130 for proto in self.protos:
131 if True not in [skip_str in proto.name for skip_str in ['Dbg', 'Wsi']]: #Dbg' not in proto.name and 'Wsi' not in proto.name:
132 func_ptrs.append('#define __HOOKED_xgl%s hooked_xgl%s' % (proto.name, proto.name))
133
134 func_ptrs.append('\n#elif defined(PLATFORM_LINUX)')
135 func_ptrs.append('extern pthread_once_t gInitOnce;')
136 for proto in self.protos:
137 if True not in [skip_str in proto.name for skip_str in ['Dbg', 'Wsi']]:
138 func_ptrs.append('#define __HOOKED_xgl%s xgl%s' % (proto.name, proto.name))
139
140 func_ptrs.append('#endif\n')
141 return "\n".join(func_ptrs)
142
143 def _generate_trace_func_ptrs_ext(self, func_class='Wsi'):
144 func_ptrs = []
145 func_ptrs.append('#ifdef WIN32')
146 for proto in self.protos:
147 if func_class in proto.name:
148 func_ptrs.append('#define __HOOKED_xgl%s hooked_xgl%s' % (proto.name, proto.name))
149
150 func_ptrs.append('#elif defined(__linux__)')
151 for proto in self.protos:
152 if func_class in proto.name:
153 func_ptrs.append('#define __HOOKED_xgl%s xgl%s' % (proto.name, proto.name))
154
155 func_ptrs.append('#endif\n')
156 return "\n".join(func_ptrs)
157
158 def _generate_trace_func_protos(self):
159 func_protos = []
160 func_protos.append('// Hooked function prototypes\n')
161 for proto in self.protos:
162 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Ian Elliotte5a22a72015-02-26 17:01:30 -0700[diff] [blame]163 func_protos.append('GLVTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_xgl", attr="XGLAPI"))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]164
165 return "\n".join(func_protos)
166
167 def _generate_trace_func_protos_ext(self, func_class='Wsi'):
168 func_protos = []
169 func_protos.append('// Hooked function prototypes\n')
170 for proto in self.protos:
171 if func_class in proto.name:
Ian Elliotte5a22a72015-02-26 17:01:30 -0700[diff] [blame]172 func_protos.append('GLVTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_xgl", attr="XGLAPI"))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]173
174 return "\n".join(func_protos)
175
176
177 def _generate_func_ptr_assignments(self):
178 func_ptr_assign = []
179 for proto in self.protos:
180 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
181 func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
182 for p in proto.params:
183 if 'color' == p.name:
184 func_ptr_assign.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))
185 else:
186 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
187 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))
188 func_ptr_assign.append('static BOOL isHooked = FALSE;\n')
189 return "\n".join(func_ptr_assign)
190
191 def _generate_func_ptr_assignments_ext(self, func_class='Wsi'):
192 func_ptr_assign = []
193 for proto in self.protos:
194 if func_class in proto.name:
195 func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
196 for p in proto.params:
197 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
198 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))
199 return "\n".join(func_ptr_assign)
200
201 def _generate_attach_hooks(self):
202 hooks_txt = []
203 hooks_txt.append('void AttachHooks()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)')
204 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]205 # TODO : Verify if CreateInstance is appropriate to key off of here
206 hooks_txt.append(' if (real_xglCreateInstance != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]207 hooks_txt.append(' {\n isHooked = TRUE;')
208 hook_operator = '='
209 for proto in self.protos:
210 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
211 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))
212 hook_operator = '&='
213 hooks_txt.append(' }\n')
214 hooks_txt.append(' if (!hookSuccess)\n {')
215 hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')
216 hooks_txt.append(' Mhook_EndMultiOperation();\n')
217 hooks_txt.append('#elif defined(__linux__)')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]218 hooks_txt.append(' if (real_xglCreateInstance == xglCreateInstance)')
219 hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateInstance,"xglCreateInstance");')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]220 hooks_txt.append(' isHooked = TRUE;')
221 for proto in self.protos:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]222 if 'Dbg' not in proto.name and 'Wsi' not in proto.name and 'CreateInstance' not in proto.name:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]223 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))
224 hooks_txt.append(' if (!hookSuccess)\n {')
225 hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')
226 hooks_txt.append('#endif\n}\n')
227 return "\n".join(hooks_txt)
228
229 def _generate_attach_hooks_ext(self, func_class='Wsi'):
230 func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}
231 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
232 hooks_txt = []
233 hooks_txt.append('void AttachHooks%s()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)' % func_ext_dict[func_class])
234 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
235 hooks_txt.append(' if (real_xgl%s != NULL)' % first_proto_dict[func_class])
236 hooks_txt.append(' {')
237 hook_operator = '='
238 for proto in self.protos:
239 if func_class in proto.name:
240 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))
241 hook_operator = '&='
242 hooks_txt.append(' }\n')
243 hooks_txt.append(' if (!hookSuccess)\n {')
244 hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)
245 hooks_txt.append(' Mhook_EndMultiOperation();\n')
246 hooks_txt.append('#elif defined(__linux__)')
247 hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (first_proto_dict[func_class], first_proto_dict[func_class]))
248 for proto in self.protos:
249 if func_class in proto.name and first_proto_dict[func_class] not in proto.name:
250 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))
251 hooks_txt.append(' if (!hookSuccess)\n {')
252 hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)
253 hooks_txt.append('#endif\n}\n')
254 return "\n".join(hooks_txt)
255
256 def _generate_detach_hooks(self):
257 hooks_txt = []
258 hooks_txt.append('void DetachHooks()\n{\n#ifdef __linux__\n return;\n#elif defined(WIN32)')
259 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xglGetGpuInfo != NULL)\n {')
260 hook_operator = '='
261 for proto in self.protos:
262 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
263 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))
264 hook_operator = '&='
265 hooks_txt.append(' }\n isHooked = FALSE;')
266 hooks_txt.append(' if (!unhookSuccess)\n {')
267 hooks_txt.append(' glv_LogError("Failed to unhook XGL.");\n }')
268 hooks_txt.append('#endif\n}')
269 hooks_txt.append('#ifdef WIN32\nINIT_ONCE gInitOnce = INIT_ONCE_STATIC_INIT;\n#elif defined(PLATFORM_LINUX)\npthread_once_t gInitOnce = PTHREAD_ONCE_INIT;\n#endif\n')
270 return "\n".join(hooks_txt)
271
272 def _generate_detach_hooks_ext(self, func_class='Wsi'):
273 func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}
274 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
275 hooks_txt = []
276 hooks_txt.append('void DetachHooks%s()\n{\n#ifdef WIN32' % func_ext_dict[func_class])
277 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xgl%s != NULL)\n {' % first_proto_dict[func_class])
278 hook_operator = '='
279 for proto in self.protos:
280 if func_class in proto.name:
281 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))
282 hook_operator = '&='
283 hooks_txt.append(' }')
284 hooks_txt.append(' if (!unhookSuccess)\n {')
285 hooks_txt.append(' glv_LogError("Failed to unhook XGL ext %s.");\n }' % func_class)
286 hooks_txt.append('#elif defined(__linux__)\n return;\n#endif\n}\n')
287 return "\n".join(hooks_txt)
288
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]289 def _generate_init_funcs(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]290 init_tracer = []
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]291 init_tracer.append('void send_xgl_api_version_packet()\n{')
292 init_tracer.append(' struct_xglApiVersion* pPacket;')
293 init_tracer.append(' glv_trace_packet_header* pHeader;')
294 init_tracer.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_xglApiVersion, sizeof(struct_xglApiVersion), 0);')
295 init_tracer.append(' pPacket = interpret_body_as_xglApiVersion(pHeader, FALSE);')
296 init_tracer.append(' pPacket->version = XGL_API_VERSION;')
297 init_tracer.append(' FINISH_TRACE_PACKET();\n}\n')
298
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]299 init_tracer.append('static GLV_CRITICAL_SECTION g_memInfoLock;')
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]300 init_tracer.append('void InitTracer(void)\n{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]301 init_tracer.append(' char *ipAddr = glv_get_global_var("GLVLIB_TRACE_IPADDR");')
302 init_tracer.append(' if (ipAddr == NULL)')
303 init_tracer.append(' ipAddr = "127.0.0.1";')
Jon Ashburn0fed6752015-01-09 17:36:10 -0700[diff] [blame]304 init_tracer.append(' gMessageStream = glv_MessageStream_create(FALSE, ipAddr, GLV_BASE_PORT + GLV_TID_XGL);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]305 init_tracer.append(' glv_trace_set_trace_file(glv_FileLike_create_msg(gMessageStream));')
306 init_tracer.append('// glv_tracelog_set_log_file(glv_FileLike_create_file(fopen("glv_log_traceside.txt","w")));')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]307 init_tracer.append(' glv_tracelog_set_tracer_id(GLV_TID_XGL);')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]308 init_tracer.append(' glv_create_critical_section(&g_memInfoLock);')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]309 init_tracer.append(' send_xgl_api_version_packet();\n}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]310 return "\n".join(init_tracer)
311
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]312 def _gen_unmap_memory(self):
313 um_body = []
314 um_body.append('GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglUnmapMemory(')
315 um_body.append(' XGL_GPU_MEMORY mem)')
316 um_body.append('{')
317 um_body.append(' glv_trace_packet_header* pHeader;')
318 um_body.append(' XGL_RESULT result;')
319 um_body.append(' struct_xglUnmapMemory* pPacket;')
320 um_body.append(' XGLAllocInfo *entry;')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]321 um_body.append(' SEND_ENTRYPOINT_PARAMS("xglUnmapMemory(mem %p)\\n", mem);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]322 um_body.append(' // insert into packet the data that was written by CPU between the xglMapMemory call and here')
323 um_body.append(' // Note must do this prior to the real xglUnMap() or else may get a FAULT')
Jon Ashburn9c8c3622015-02-25 13:51:07 -0700[diff] [blame]324 um_body.append(' glv_enter_critical_section(&g_memInfoLock);')
325 um_body.append(' entry = find_mem_info_entry(mem);')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]326 um_body.append(' CREATE_TRACE_PACKET(xglUnmapMemory, (entry) ? entry->size : 0);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]327 um_body.append(' pPacket = interpret_body_as_xglUnmapMemory(pHeader);')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]328 um_body.append(' if (entry)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]329 um_body.append(' {')
330 um_body.append(' assert(entry->handle == mem);')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]331 um_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pData), entry->size, entry->pData);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]332 um_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));')
333 um_body.append(' entry->pData = NULL;')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]334 um_body.append(' } else')
335 um_body.append(' {')
336 um_body.append(' glv_LogError("Failed to copy app memory into trace packet (idx = %u) on xglUnmapMemory\\n", pHeader->global_packet_index);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]337 um_body.append(' }')
Jon Ashburn9c8c3622015-02-25 13:51:07 -0700[diff] [blame]338 um_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]339 um_body.append(' result = real_xglUnmapMemory(mem);')
340 um_body.append(' pPacket->mem = mem;')
341 um_body.append(' pPacket->result = result;')
342 um_body.append(' FINISH_TRACE_PACKET();')
343 um_body.append(' return result;')
344 um_body.append('}\n')
345 return "\n".join(um_body)
346
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]347 # Take a list of params and return a list of dicts w/ ptr param details
348 def _get_packet_ptr_param_list(self, params):
349 ptr_param_list = []
350 # TODO : This is a slightly nicer way to handle custom cases than initial code, however
351 # this can still be further generalized to eliminate more custom code
352 # big case to handle is when ptrs to structs have embedded data that needs to be accounted for in packet
353 custom_ptr_dict = {'XGL_DEVICE_CREATE_INFO': {'add_txt': 'add_XGL_DEVICE_CREATE_INFO_to_packet(pHeader, (XGL_DEVICE_CREATE_INFO**) &(pPacket->pCreateInfo), pCreateInfo)',
354 'finalize_txt': ''},
355 'XGL_APPLICATION_INFO': {'add_txt': 'add_XGL_APPLICATION_INFO_to_packet(pHeader, (XGL_APPLICATION_INFO**)&(pPacket->pAppInfo), pAppInfo)',
356 'finalize_txt': ''},
357 'XGL_PHYSICAL_GPU': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), *pGpuCount*sizeof(XGL_PHYSICAL_GPU), pGpus)',
358 'finalize_txt': 'default'},
359 'pDataSize': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize)',
360 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize))'},
361 'pData': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData)',
362 'finalize_txt': 'default'},
363 'pName': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pName), ((pName != NULL) ? strlen(pName) + 1 : 0), pName)',
364 'finalize_txt': 'default'},
365 'pExtName': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pExtName), ((pExtName != NULL) ? strlen(pExtName) + 1 : 0), pExtName)',
366 'finalize_txt': 'default'},
367 'pDescriptorSets': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), customSize, pDescriptorSets)',
368 'finalize_txt': 'default'},
369 'pUpdateChain': {'add_txt': 'add_update_descriptors_to_trace_packet(pHeader, (void**)&(pPacket->pUpdateChain), pUpdateChain)',
370 'finalize_txt': 'default'},
371 'XGL_SHADER_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_SHADER_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), ((pCreateInfo != NULL) ? pCreateInfo->codeSize : 0), pCreateInfo->pCode)',
372 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
373 'XGL_FRAMEBUFFER_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_FRAMEBUFFER_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments), colorCount * sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO), pCreateInfo->pColorAttachments);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment), dsSize, pCreateInfo->pDepthStencilAttachment)',
374 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
375 'XGL_RENDER_PASS_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_RENDER_PASS_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps), colorCount * sizeof(XGL_ATTACHMENT_LOAD_OP), pCreateInfo->pColorLoadOps);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps), colorCount * sizeof(XGL_ATTACHMENT_STORE_OP), pCreateInfo->pColorStoreOps);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues), colorCount * sizeof(XGL_CLEAR_COLOR), pCreateInfo->pColorLoadClearValues)',
376 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
377 'XGL_CMD_BUFFER_BEGIN_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pBeginInfo), sizeof(XGL_CMD_BUFFER_BEGIN_INFO), pBeginInfo);\n add_begin_cmdbuf_to_trace_packet(pHeader, (void**)&(pPacket->pBeginInfo->pNext), pBeginInfo->pNext)',
378 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBeginInfo))'},
379 'XGL_DYNAMIC_VP_STATE_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pViewports), vpsCount * sizeof(XGL_VIEWPORT), pCreateInfo->pViewports);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pScissors), vpsCount * sizeof(XGL_RECT), pCreateInfo->pScissors)',
380 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pViewports));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pScissors));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
381 'XGL_MEMORY_ALLOC_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo), sizeof(XGL_MEMORY_ALLOC_INFO), pAllocInfo);\n add_alloc_memory_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo->pNext), pAllocInfo->pNext)',
382 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocInfo))'},
383 'XGL_GRAPHICS_PIPELINE_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO), pCreateInfo);\n add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext)',
384 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
385 'XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSetLayoutInfoList), sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO), pSetLayoutInfoList);\n if (pSetLayoutInfoList)\n add_create_ds_layout_to_trace_packet(pHeader, (void**)&(pPacket->pSetLayoutInfoList->pNext), pSetLayoutInfoList->pNext)',
386 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSetLayoutInfoList))'},
387 'XGL_DESCRIPTOR_REGION_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount), rgCount * sizeof(XGL_DESCRIPTOR_TYPE_COUNT), pCreateInfo->pTypeCount)',
388 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
389 'XGL_COMPUTE_PIPELINE_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO), pCreateInfo);\n add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext);\n add_pipeline_shader_to_trace_packet(pHeader, (XGL_PIPELINE_SHADER*)&pPacket->pCreateInfo->cs, &pCreateInfo->cs)',
390 'finalize_txt': 'finalize_pipeline_shader_address(pHeader, &pPacket->pCreateInfo->cs);\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
391 }
392 for p in params:
393 pp_dict = {}
394 if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
395 if 'const' in p.ty.lower() and 'count' in params[params.index(p)-1].name.lower():
396 pp_dict['add_txt'] = 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s*sizeof(%s), %s)' % (p.name, params[params.index(p)-1].name, p.ty.strip('*').replace('const ', ''), p.name)
397 elif p.ty.strip('*').replace('const ', '') in custom_ptr_dict:
398 pp_dict['add_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['add_txt']
399 pp_dict['finalize_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['finalize_txt']
400 elif p.name in custom_ptr_dict:
401 pp_dict['add_txt'] = custom_ptr_dict[p.name]['add_txt']
402 pp_dict['finalize_txt'] = custom_ptr_dict[p.name]['finalize_txt']
403 # TODO : This is custom hack to account for 2 pData items with dataSize param for sizing
404 if 'pData' == p.name and 'dataSize' == params[params.index(p)-1].name:
405 pp_dict['add_txt'] = pp_dict['add_txt'].replace('_dataSize', 'dataSize')
406 else:
407 pp_dict['add_txt'] = 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s)' % (p.name, p.ty.strip('*').replace('const ', ''), p.name)
408 if 'finalize_txt' not in pp_dict or 'default' == pp_dict['finalize_txt']:
409 pp_dict['finalize_txt'] = 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s))' % (p.name)
410 pp_dict['index'] = params.index(p)
411 ptr_param_list.append(pp_dict)
412 return ptr_param_list
413
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]414 # Take a list of params and return a list of packet size elements
415 def _get_packet_size(self, params):
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]416 ps = [] # List of elements to be added together to account for packet size for given params
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]417 skip_list = [] # store params that are already accounted for so we don't count them twice
418 # Dict of specific params with unique custom sizes
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]419 custom_size_dict = {'pSetBindPoints': '(XGL_SHADER_STAGE_COMPUTE * sizeof(uint32_t))', # Accounting for largest possible array
420 }
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]421 for p in params:
422 #First handle custom cases
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]423 if p.name in ['pCreateInfo', 'pUpdateChain', 'pSetLayoutInfoList', 'pBeginInfo', 'pAllocInfo']:
424 ps.append('get_struct_chain_size((void*)%s)' % p.name)
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]425 skip_list.append(p.name)
426 elif p.name in custom_size_dict:
427 ps.append(custom_size_dict[p.name])
428 skip_list.append(p.name)
429 # Skip any params already handled
430 if p.name in skip_list:
431 continue
432 # Now check to identify dynamic arrays which depend on two params
433 if 'count' in p.name.lower():
434 next_idx = params.index(p)+1
435 # If next element is a const *, then multiply count and array type
436 if next_idx < len(params) and '*' in params[next_idx].ty and 'const' in params[next_idx].ty.lower():
437 if '*' in p.ty:
438 ps.append('*%s*sizeof(%s)' % (p.name, params[next_idx].ty.strip('*').replace('const ', '')))
439 else:
440 ps.append('%s*sizeof(%s)' % (p.name, params[next_idx].ty.strip('*').replace('const ', '')))
441 skip_list.append(params[next_idx].name)
442 elif '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
443 if 'pData' == p.name:
444 if 'dataSize' == params[params.index(p)-1].name:
445 ps.append('dataSize')
446 elif 'counterCount' == params[params.index(p)-1].name:
447 ps.append('sizeof(%s)' % p.ty.strip('*').replace('const ', ''))
448 else:
449 ps.append('((pDataSize != NULL && pData != NULL) ? *pDataSize : 0)')
450 elif '**' in p.ty and 'void' in p.ty:
451 ps.append('sizeof(void*)')
452 elif 'void' in p.ty:
453 ps.append('sizeof(%s)' % p.name)
454 elif 'char' in p.ty:
455 ps.append('((%s != NULL) ? strlen(%s) + 1 : 0)' % (p.name, p.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]456 elif 'pDataSize' in p.name:
457 ps.append('((pDataSize != NULL) ? sizeof(size_t) : 0)')
458 elif 'IMAGE_SUBRESOURCE' in p.ty and 'pSubresource' == p.name:
459 ps.append('((pSubresource != NULL) ? sizeof(XGL_IMAGE_SUBRESOURCE) : 0)')
460 else:
461 ps.append('sizeof(%s)' % (p.ty.strip('*').replace('const ', '')))
462 return ps
463
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]464 # Generate functions used to trace API calls and store the input and result data into a packet
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]465 # Here's the general flow of code insertion w/ option items flagged w/ "?"
466 # Result decl?
467 # Packet struct decl
468 # ?Special case : setup call to function first and do custom API call time tracking
469 # CREATE_PACKET
470 # Call (w/ result?)
471 # Assign packet values
472 # FINISH packet
473 # return result?
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]474 def _generate_trace_funcs(self):
475 func_body = []
476 for proto in self.protos:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]477 if 'UnmapMemory' == proto.name:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]478 func_body.append(self._gen_unmap_memory())
479 elif 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]480 raw_packet_update_list = [] # non-ptr elements placed directly into packet
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]481 ptr_packet_update_list = [] # ptr elements to be updated into packet
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]482 return_txt = ''
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]483 packet_size = []
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]484 in_data_size = False # flag when we need to capture local input size variable for in/out size
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]485 func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]486 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 if NULL
487 if '[' in p.ty: # Correctly declare static arrays in function parameters
488 func_body.append(' %s %s[%s],' % (p.ty[:p.ty.find('[')], p.name, p.ty[p.ty.find('[')+1:p.ty.find(']')]))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]489 else:
490 func_body.append(' %s %s,' % (p.ty, p.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]491 if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
492 if 'pDataSize' in p.name:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]493 in_data_size = True;
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]494 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]495 if '[' in p.ty:
Tobin Ehlis8a5a85b2015-02-25 11:30:27 -0700[diff] [blame]496 array_str = p.ty[p.ty.find('[')+1:p.ty.find(']')]
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]497 raw_packet_update_list.append(' memcpy((void*)pPacket->color, color, %s * sizeof(%s));' % (array_str, p.ty.strip('*').replace('const ', '').replace('[%s]' % array_str, '')))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]498 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]499 raw_packet_update_list.append(' pPacket->%s = %s;' % (p.name, p.name))
500 # Get list of packet size modifiers due to ptr params
501 packet_size = self._get_packet_size(proto.params)
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]502 ptr_packet_update_list = self._get_packet_ptr_param_list(proto.params)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]503 func_body[-1] = func_body[-1].replace(',', ')')
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]504 # End of function declaration portion, begin function body
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]505 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]506 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]507 func_body.append(' %s result;' % proto.ret)
508 return_txt = 'result = '
509 if in_data_size:
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]510 func_body.append(' size_t _dataSize;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]511 func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]512 # functions that have non-standard sequence of packet creation and calling real function
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]513 # NOTE: Anytime we call the function before CREATE_TRACE_PACKET, need to add custom code for correctly tracking API call time
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]514 if 'CreateInstance' == proto.name:
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]515 func_body.append(' uint64_t startTime;')
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]516 func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')
517 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
518 func_body.append(' if (real_xglCreateInstance == xglCreateInstance)')
519 func_body.append(' {')
520 func_body.append(' glv_platform_get_next_lib_sym((void **) &real_xglCreateInstance,"xglCreateInstance");')
521 func_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]522 func_body.append(' startTime = glv_get_time();')
523 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Tobin Ehlis284cf2d2015-03-16 08:21:33 -0600[diff] [blame]524 func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(XGL_INSTANCE) + get_struct_chain_size((void*)pAppInfo) + ((pAllocCb == NULL) ? 0 :sizeof(XGL_ALLOC_CALLBACKS)));' % (proto.name))
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]525 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]526 func_body.append(' if (isHooked == FALSE) {')
527 func_body.append(' AttachHooks();')
528 func_body.append(' AttachHooks_xgldbg();')
529 func_body.append(' AttachHooks_xglwsix11ext();')
530 func_body.append(' }')
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]531 elif 'EnumerateGpus' == proto.name:
532 func_body.append(' uint64_t startTime;')
533 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
534 func_body.append(' startTime = glv_get_time();')
535 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
536 func_body.append(' CREATE_TRACE_PACKET(xglEnumerateGpus, sizeof(uint32_t) + ((pGpus && pGpuCount) ? *pGpuCount * sizeof(XGL_PHYSICAL_GPU) : 0));')
537 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
538 elif 'EnumerateLayers' == proto.name:
539 func_body.append(' uint64_t startTime;')
540 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
541 func_body.append(' startTime = glv_get_time();')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]542 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]543 func_body.append(' size_t totStringSize = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]544 func_body.append(' uint32_t i = 0;')
545 func_body.append(' for (i = 0; i < *pOutLayerCount; i++)')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]546 func_body.append(' totStringSize += (pOutLayers[i] != NULL) ? strlen(pOutLayers[i]) + 1: 0;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]547 func_body.append(' CREATE_TRACE_PACKET(xgl%s, totStringSize + sizeof(size_t));' % (proto.name))
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]548 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]549 elif 'AllocDescriptorSets' == proto.name:
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]550 func_body.append(' uint64_t startTime;')
551 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
552 func_body.append(' startTime = glv_get_time();')
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]553 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
554 func_body.append(' size_t customSize = (*pCount <= 0) ? (sizeof(XGL_DESCRIPTOR_SET)) : (*pCount * sizeof(XGL_DESCRIPTOR_SET));')
555 func_body.append(' CREATE_TRACE_PACKET(xglAllocDescriptorSets, sizeof(XGL_DESCRIPTOR_SET_LAYOUT) + customSize + sizeof(uint32_t));')
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]556 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]557 elif proto.name in ['CreateFramebuffer', 'CreateRenderPass', 'CreateDynamicViewportState',
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]558 'CreateDescriptorRegion', 'CmdWaitEvents', 'CmdPipelineBarrier']:
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]559 # these are regular case as far as sequence of tracing but have some custom size element
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]560 if 'CreateFramebuffer' == proto.name:
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]561 func_body.append(' int dsSize = (pCreateInfo != NULL && pCreateInfo->pDepthStencilAttachment != NULL) ? sizeof(XGL_DEPTH_STENCIL_BIND_INFO) : 0;')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]562 func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && pCreateInfo->pColorAttachments != NULL) ? pCreateInfo->colorAttachmentCount : 0;')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]563 func_body.append(' CREATE_TRACE_PACKET(xglCreateFramebuffer, get_struct_chain_size((void*)pCreateInfo) + sizeof(XGL_FRAMEBUFFER));')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]564 elif 'CreateRenderPass' == proto.name:
Jon Ashburnec7dcb42015-02-20 10:30:32 -0700[diff] [blame]565 func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && (pCreateInfo->pColorLoadOps != NULL || pCreateInfo->pColorStoreOps != NULL || pCreateInfo->pColorLoadClearValues != NULL)) ? pCreateInfo->colorAttachmentCount : 0;')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]566 func_body.append(' CREATE_TRACE_PACKET(xglCreateRenderPass, get_struct_chain_size((void*)pCreateInfo) + sizeof(XGL_RENDER_PASS));')
Jon Ashburn8e7dcd02015-02-04 08:50:35 -0700[diff] [blame]567 elif 'CreateDynamicViewportState' == proto.name:
Courtney Goeltzenleuchterc6e32f92015-02-11 14:13:34 -0700[diff] [blame]568 func_body.append(' uint32_t vpsCount = (pCreateInfo != NULL && pCreateInfo->pViewports != NULL) ? pCreateInfo->viewportAndScissorCount : 0;')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]569 func_body.append(' CREATE_TRACE_PACKET(xglCreateDynamicViewportState, get_struct_chain_size((void*)pCreateInfo) + sizeof(XGL_DYNAMIC_VP_STATE_OBJECT));')
Jon Ashburnfb3769a2015-02-04 09:32:59 -0700[diff] [blame]570 elif 'CreateDescriptorRegion' == proto.name:
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]571 func_body.append(' uint32_t rgCount = (pCreateInfo != NULL && pCreateInfo->pTypeCount != NULL) ? pCreateInfo->count : 0;')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]572 func_body.append(' CREATE_TRACE_PACKET(xglCreateDescriptorRegion, get_struct_chain_size((void*)pCreateInfo) + sizeof(XGL_DESCRIPTOR_REGION));')
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]573 else: # ['CmdWaitEvents', 'CmdPipelineBarrier']:
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]574 func_body.append(' size_t customSize;')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]575 event_array_type = 'XGL_EVENT'
576 if 'CmdPipelineBarrier' == proto.name:
577 event_array_type = 'XGL_SET_EVENT'
578 func_body.append(' uint32_t eventCount = (%s != NULL && %s->pEvents != NULL) ? %s->eventCount : 0;' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].name))
579 func_body.append(' uint32_t mbCount = (%s != NULL && %s->ppMemBarriers != NULL) ? %s->memBarrierCount : 0;' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].name))
Jon Ashburn1751d7a2015-02-10 13:49:30 -0700[diff] [blame]580 func_body.append(' customSize = (eventCount * sizeof(%s)) + mbCount * sizeof(void*) + calculate_memory_barrier_size(mbCount, %s->ppMemBarriers);' % (event_array_type, proto.params[-1].name))
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]581 func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(%s) + customSize);' % (proto.name, proto.params[-1].ty.strip('*').replace('const ', '')))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]582 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
583 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]584 if (0 == len(packet_size)):
585 func_body.append(' CREATE_TRACE_PACKET(xgl%s, 0);' % (proto.name))
586 else:
587 func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, ' + '.join(packet_size)))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]588 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]589 if in_data_size:
590 func_body.append(' _dataSize = (pDataSize == NULL || pData == NULL) ? 0 : *pDataSize;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]591 func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]592 func_body.append('\n'.join(raw_packet_update_list))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]593 if 'MapMemory' == proto.name: # Custom code for MapMem case
594 func_body.append(' if (ppData != NULL)')
595 func_body.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]596 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppData), sizeof(void*), *ppData);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]597 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));')
598 func_body.append(' add_data_to_mem_info(mem, *ppData);')
599 func_body.append(' }')
600 func_body.append(' pPacket->result = result;')
601 func_body.append(' FINISH_TRACE_PACKET();')
602 elif 'EnumerateLayers' == proto.name: #custom code for EnumerateLayers case
603 func_body.append(' pPacket->gpu = gpu;')
604 func_body.append(' pPacket->maxLayerCount = maxLayerCount;')
605 func_body.append(' pPacket->maxStringSize = maxStringSize;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]606 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayerCount), sizeof(size_t), pOutLayerCount);')
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]607 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayerCount));')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]608 func_body.append(' for (i = 0; i < *pOutLayerCount; i++) {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]609 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayers[i]), ((pOutLayers[i] != NULL) ? strlen(pOutLayers[i]) + 1 : 0), pOutLayers[i]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]610 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayers[i]));')
611 func_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]612
613 func_body.append(' pPacket->pReserved = pReserved;')
614 func_body.append(' pPacket->result = result;')
615 func_body.append(' FINISH_TRACE_PACKET();')
616 else:
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]617 for pp_dict in ptr_packet_update_list: #buff_ptr_indices:
618 func_body.append(' %s;' % (pp_dict['add_txt']))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]619 # Some custom add_* and finalize_* function calls for Create* API calls
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]620 if proto.name in ['CmdWaitEvents', 'CmdPipelineBarrier']:
621 event_array_type = 'XGL_EVENT'
622 if 'CmdPipelineBarrier' == proto.name:
623 event_array_type = 'XGL_SET_EVENT'
624 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->pEvents), eventCount * sizeof(%s), %s->pEvents);' % (proto.params[-1].name, event_array_type, proto.params[-1].name))
625 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->pEvents));' % (proto.params[-1].name))
626 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->ppMemBarriers), mbCount * sizeof(void*), %s->ppMemBarriers);' % (proto.params[-1].name, proto.params[-1].name))
627 func_body.append(' uint32_t i, siz;')
628 func_body.append(' for (i = 0; i < mbCount; i++) {')
629 func_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) %s->ppMemBarriers[i];' % proto.params[-1].name)
630 func_body.append(' switch (pNext->sType) {')
631 func_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:')
632 func_body.append(' siz = sizeof(XGL_MEMORY_BARRIER);')
633 func_body.append(' break;')
634 func_body.append(' case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:')
635 func_body.append(' siz = sizeof(XGL_BUFFER_MEMORY_BARRIER);')
636 func_body.append(' break;')
637 func_body.append(' case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:')
638 func_body.append(' siz = sizeof(XGL_IMAGE_MEMORY_BARRIER);')
639 func_body.append(' break;')
640 func_body.append(' default:')
641 func_body.append(' assert(0);')
642 func_body.append(' siz = 0;')
643 func_body.append(' break;')
644 func_body.append(' }')
645 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->ppMemBarriers[i]), siz, %s->ppMemBarriers[i]);' % (proto.params[-1].name, proto.params[-1].name))
646 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->ppMemBarriers[i]));' % (proto.params[-1].name))
647 func_body.append(' }')
648 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->ppMemBarriers));' % (proto.params[-1].name))
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]649 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]650 func_body.append(' pPacket->result = result;')
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]651 for pp_dict in ptr_packet_update_list:
652 if ('DEVICE_CREATE_INFO' not in proto.params[pp_dict['index']].ty) and ('APPLICATION_INFO' not in proto.params[pp_dict['index']].ty) and ('pUpdateChain' != proto.params[pp_dict['index']].name):
653 func_body.append(' %s;' % (pp_dict['finalize_txt']))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]654 func_body.append(' FINISH_TRACE_PACKET();')
655 if 'AllocMemory' in proto.name:
656 func_body.append(' add_new_handle_to_mem_info(*pMem, pAllocInfo->allocationSize, NULL);')
657 elif 'FreeMemory' in proto.name:
658 func_body.append(' rm_handle_from_mem_info(mem);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]659 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]660 func_body.append(' return result;')
661 func_body.append('}\n')
662 return "\n".join(func_body)
663
664 def _generate_trace_funcs_ext(self, func_class='Wsi'):
665 thread_once_funcs = ['DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback', 'DbgSetGlobalOption']
666 func_body = []
667 for proto in self.protos:
668 if func_class in proto.name:
669 packet_update_txt = ''
670 return_txt = ''
671 packet_size = ''
672 buff_ptr_indices = []
673 func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))
674 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL
675 func_body.append(' %s %s,' % (p.ty, p.name))
676 if 'Size' in p.name:
677 packet_size += p.name
678 if '*' in p.ty and 'pSysMem' != p.name:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]679 if 'char' in p.ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]680 packet_size += '((%s != NULL) ? strlen(%s) + 1 : 0) + ' % (p.name, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]681 elif 'Size' not in packet_size:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]682 packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]683 buff_ptr_indices.append(proto.params.index(p))
684 if 'pConnectionInfo' in p.name:
685 packet_size += '((pConnectionInfo->pConnection != NULL) ? sizeof(void *) : 0)'
686 else:
687 packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)
688 if '' == packet_size:
689 packet_size = '0'
690 else:
691 packet_size = packet_size.strip(' + ')
692 func_body[-1] = func_body[-1].replace(',', ')')
693 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]694 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]695 func_body.append(' %s result;' % proto.ret)
696 return_txt = 'result = '
697 func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)
698 if proto.name in thread_once_funcs:
699 func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')
700 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]701 if 'DbgRegisterMsgCallback' in proto.name:
702 func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(char));' % proto.name)
703 else:
704 func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]705 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
706 func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)
707 func_body.append(packet_update_txt.strip('\n'))
708 for idx in buff_ptr_indices:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]709 if 'char' in proto.params[idx].ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]710 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), ((%s != NULL) ? strlen(%s) + 1 : 0), %s);' % (proto.params[idx].name, proto.params[idx].name, proto.params[idx].name, proto.params[idx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]711 elif 'Size' in proto.params[idx-1].name:
712 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s, %s);' % (proto.params[idx].name, proto.params[idx-1].name, proto.params[idx].name))
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]713 elif 'DbgRegisterMsgCallback' in proto.name:
714 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s);' % (proto.params[idx].name, 'char', proto.params[idx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]715 else:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]716 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s);' % (proto.params[idx].name, proto.params[idx].ty.strip('*').replace('const ', ''), proto.params[idx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]717 if 'WsiX11AssociateConnection' in proto.name:
718 func_body.append(' if (pConnectionInfo->pConnection != NULL) {')
719 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection), sizeof(void *), pConnectionInfo->pConnection);')
720 func_body.append(' glv_finalize_buffer_address(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection));')
721 func_body.append(' }')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]722 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]723 func_body.append(' pPacket->result = result;')
724 for idx in buff_ptr_indices:
725 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))
726 func_body.append(' FINISH_TRACE_PACKET();')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]727 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]728 func_body.append(' return result;')
729 func_body.append('}\n')
730 return "\n".join(func_body)
731
732 def _generate_helper_funcs(self):
733 hf_body = []
734 hf_body.append('// Support for shadowing CPU mapped memory')
735 hf_body.append('typedef struct _XGLAllocInfo {')
736 hf_body.append(' XGL_GPU_SIZE size;')
737 hf_body.append(' XGL_GPU_MEMORY handle;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]738 hf_body.append(' void *pData;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]739 hf_body.append(' BOOL valid;')
740 hf_body.append('} XGLAllocInfo;')
741 hf_body.append('typedef struct _XGLMemInfo {')
742 hf_body.append(' unsigned int numEntrys;')
743 hf_body.append(' XGLAllocInfo *pEntrys;')
744 hf_body.append(' XGLAllocInfo *pLastMapped;')
745 hf_body.append(' unsigned int capacity;')
746 hf_body.append('} XGLMemInfo;')
747 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]748 hf_body.append('static XGLMemInfo g_memInfo = {0, NULL, NULL, 0};')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]749 hf_body.append('')
750 hf_body.append('static void init_mem_info_entrys(XGLAllocInfo *ptr, const unsigned int num)')
751 hf_body.append('{')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]752 hf_body.append(' unsigned int i;')
753 hf_body.append(' for (i = 0; i < num; i++)')
754 hf_body.append(' {')
755 hf_body.append(' XGLAllocInfo *entry = ptr + i;')
756 hf_body.append(' entry->pData = NULL;')
757 hf_body.append(' entry->size = 0;')
758 hf_body.append(' entry->handle = NULL;')
759 hf_body.append(' entry->valid = FALSE;')
760 hf_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]761 hf_body.append('}')
762 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]763 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]764 hf_body.append('static void init_mem_info()')
765 hf_body.append('{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]766 hf_body.append(' g_memInfo.numEntrys = 0;')
Jon Ashburn51a52e82015-02-20 14:48:27 -0700[diff] [blame]767 hf_body.append(' g_memInfo.capacity = 4096;')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]768 hf_body.append(' g_memInfo.pLastMapped = NULL;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]769 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]770 hf_body.append(' g_memInfo.pEntrys = GLV_NEW_ARRAY(XGLAllocInfo, g_memInfo.capacity);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]771 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]772 hf_body.append(' if (g_memInfo.pEntrys == NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]773 hf_body.append(' glv_LogError("init_mem_info() malloc failed\\n");')
774 hf_body.append(' else')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]775 hf_body.append(' init_mem_info_entrys(g_memInfo.pEntrys, g_memInfo.capacity);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]776 hf_body.append('}')
777 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]778 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]779 hf_body.append('static void delete_mem_info()')
780 hf_body.append('{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]781 hf_body.append(' GLV_DELETE(g_memInfo.pEntrys);')
782 hf_body.append(' g_memInfo.pEntrys = NULL;')
783 hf_body.append(' g_memInfo.numEntrys = 0;')
784 hf_body.append(' g_memInfo.capacity = 0;')
785 hf_body.append(' g_memInfo.pLastMapped = NULL;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]786 hf_body.append('}')
787 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]788 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]789 hf_body.append('static XGLAllocInfo * get_mem_info_entry()')
790 hf_body.append('{')
791 hf_body.append(' unsigned int i;')
792 hf_body.append(' XGLAllocInfo *entry;')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]793 hf_body.append(' if (g_memInfo.numEntrys > g_memInfo.capacity)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]794 hf_body.append(' {')
Jon Ashburn51a52e82015-02-20 14:48:27 -0700[diff] [blame]795 hf_body.append(' glv_LogError("get_mem_info_entry() bad internal state numEntrys %u\\n", g_memInfo.numEntrys);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]796 hf_body.append(' return NULL;')
797 hf_body.append(' }')
798 hf_body.append('')
Jon Ashburn51a52e82015-02-20 14:48:27 -0700[diff] [blame]799 hf_body.append(' entry = g_memInfo.pEntrys;')
800 hf_body.append(' for (i = 0; i < g_memInfo.numEntrys; i++)')
801 hf_body.append(' {')
802 hf_body.append(' if ((entry + i)->valid == FALSE)')
803 hf_body.append(' return entry + i;')
804 hf_body.append(' }')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]805 hf_body.append(' if (g_memInfo.numEntrys == g_memInfo.capacity)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]806 hf_body.append(' { // grow the array 2x')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]807 hf_body.append(' g_memInfo.capacity *= 2;')
808 hf_body.append(' g_memInfo.pEntrys = (XGLAllocInfo *) GLV_REALLOC(g_memInfo.pEntrys, g_memInfo.capacity * sizeof(XGLAllocInfo));')
Jon Ashburn51a52e82015-02-20 14:48:27 -0700[diff] [blame]809 hf_body.append(' if (g_memInfo.pEntrys == NULL)')
810 hf_body.append(' glv_LogError("get_mem_info_entry() realloc failed\\n");')
811 hf_body.append(' //glv_LogInfo("realloc memInfo from %u to %u\\n", g_memInfo.capacity /2, g_memInfo.capacity);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]812 hf_body.append(' //init the newly added entrys')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]813 hf_body.append(' init_mem_info_entrys(g_memInfo.pEntrys + g_memInfo.capacity / 2, g_memInfo.capacity / 2);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]814 hf_body.append(' }')
815 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]816 hf_body.append(' assert(g_memInfo.numEntrys < g_memInfo.capacity);')
Jon Ashburn51a52e82015-02-20 14:48:27 -0700[diff] [blame]817 hf_body.append(' entry = g_memInfo.pEntrys + g_memInfo.numEntrys;')
818 hf_body.append(' g_memInfo.numEntrys++;')
819 hf_body.append(' assert(entry->valid == FALSE);')
820 hf_body.append(' return entry;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]821 hf_body.append('}')
822 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]823 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]824 hf_body.append('static XGLAllocInfo * find_mem_info_entry(const XGL_GPU_MEMORY handle)')
825 hf_body.append('{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]826 hf_body.append(' XGLAllocInfo *entry;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]827 hf_body.append(' unsigned int i;')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]828 hf_body.append(' entry = g_memInfo.pEntrys;')
829 hf_body.append(' if (g_memInfo.pLastMapped && g_memInfo.pLastMapped->handle == handle && g_memInfo.pLastMapped->valid)')
830 hf_body.append(' {')
831 hf_body.append(' return g_memInfo.pLastMapped;')
832 hf_body.append(' }')
833 hf_body.append(' for (i = 0; i < g_memInfo.numEntrys; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]834 hf_body.append(' {')
835 hf_body.append(' if ((entry + i)->valid && (handle == (entry + i)->handle))')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]836 hf_body.append(' {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]837 hf_body.append(' return entry + i;')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]838 hf_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]839 hf_body.append(' }')
840 hf_body.append('')
841 hf_body.append(' return NULL;')
842 hf_body.append('}')
843 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]844 hf_body.append('static XGLAllocInfo * find_mem_info_entry_lock(const XGL_GPU_MEMORY handle)')
845 hf_body.append('{')
846 hf_body.append(' XGLAllocInfo *res;')
847 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
848 hf_body.append(' res = find_mem_info_entry(handle);')
849 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
850 hf_body.append(' return res;')
851 hf_body.append('}')
852 hf_body.append('')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]853 hf_body.append('static void add_new_handle_to_mem_info(const XGL_GPU_MEMORY handle, XGL_GPU_SIZE size, void *pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]854 hf_body.append('{')
855 hf_body.append(' XGLAllocInfo *entry;')
856 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]857 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
858 hf_body.append(' if (g_memInfo.capacity == 0)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]859 hf_body.append(' init_mem_info();')
860 hf_body.append('')
861 hf_body.append(' entry = get_mem_info_entry();')
862 hf_body.append(' if (entry)')
863 hf_body.append(' {')
864 hf_body.append(' entry->valid = TRUE;')
865 hf_body.append(' entry->handle = handle;')
866 hf_body.append(' entry->size = size;')
867 hf_body.append(' entry->pData = pData; // NOTE: xglFreeMemory will free this mem, so no malloc()')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]868 hf_body.append(' }')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]869 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]870 hf_body.append('}')
871 hf_body.append('')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]872 hf_body.append('static void add_data_to_mem_info(const XGL_GPU_MEMORY handle, void *pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]873 hf_body.append('{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]874 hf_body.append(' XGLAllocInfo *entry;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]875 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]876 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
877 hf_body.append(' entry = find_mem_info_entry(handle);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]878 hf_body.append(' if (entry)')
879 hf_body.append(' {')
880 hf_body.append(' entry->pData = pData;')
881 hf_body.append(' }')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]882 hf_body.append(' g_memInfo.pLastMapped = entry;')
883 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]884 hf_body.append('}')
885 hf_body.append('')
886 hf_body.append('static void rm_handle_from_mem_info(const XGL_GPU_MEMORY handle)')
887 hf_body.append('{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]888 hf_body.append(' XGLAllocInfo *entry;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]889 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]890 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
891 hf_body.append(' entry = find_mem_info_entry(handle);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]892 hf_body.append(' if (entry)')
893 hf_body.append(' {')
894 hf_body.append(' entry->valid = FALSE;')
895 hf_body.append(' entry->pData = NULL;')
896 hf_body.append(' entry->size = 0;')
897 hf_body.append(' entry->handle = NULL;')
898 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]899 hf_body.append(' if (entry == g_memInfo.pLastMapped)')
900 hf_body.append(' g_memInfo.pLastMapped = NULL;')
Jon Ashburn7c4d26f2015-02-26 11:45:28 -0700[diff] [blame]901 hf_body.append(' // adjust numEntrys to be last valid entry in list')
902 hf_body.append(' do {')
903 hf_body.append(' entry = g_memInfo.pEntrys + g_memInfo.numEntrys - 1;')
904 hf_body.append(' if (entry->valid == FALSE)')
905 hf_body.append(' g_memInfo.numEntrys--;')
906 hf_body.append(' } while ((entry->valid == FALSE) && (g_memInfo.numEntrys > 0));')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]907 hf_body.append(' if (g_memInfo.numEntrys == 0)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]908 hf_body.append(' delete_mem_info();')
909 hf_body.append(' }')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]910 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]911 hf_body.append('}')
912 hf_body.append('')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]913 hf_body.append('static void add_begin_cmdbuf_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]914 hf_body.append('{')
915 hf_body.append(' const XGL_CMD_BUFFER_BEGIN_INFO* pInNow = pIn;')
916 hf_body.append(' XGL_CMD_BUFFER_BEGIN_INFO** ppOutNext = (XGL_CMD_BUFFER_BEGIN_INFO**)ppOut;')
917 hf_body.append(' while (pInNow != NULL)')
918 hf_body.append(' {')
919 hf_body.append(' XGL_CMD_BUFFER_BEGIN_INFO** ppOutNow = ppOutNext;')
920 hf_body.append(' ppOutNext = NULL;')
921 hf_body.append('')
922 hf_body.append(' switch (pInNow->sType)')
923 hf_body.append(' {')
924 hf_body.append(' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:')
925 hf_body.append(' {')
926 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO), pInNow);')
927 hf_body.append(' ppOutNext = (XGL_CMD_BUFFER_BEGIN_INFO**)&(*ppOutNow)->pNext;')
928 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
929 hf_body.append(' break;')
930 hf_body.append(' }')
931 hf_body.append(' default:')
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]932 hf_body.append(' assert(!"Encountered an unexpected type in cmdbuffer_begin_info list");')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]933 hf_body.append(' }')
934 hf_body.append(' pInNow = (XGL_CMD_BUFFER_BEGIN_INFO*)pInNow->pNext;')
935 hf_body.append(' }')
936 hf_body.append(' return;')
937 hf_body.append('}')
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]938 hf_body.append('')
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]939 hf_body.append('static void add_alloc_memory_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
940 hf_body.append('{')
941 hf_body.append(' const XGL_MEMORY_ALLOC_INFO* pInNow = pIn;')
942 hf_body.append(' XGL_MEMORY_ALLOC_INFO** ppOutNext = (XGL_MEMORY_ALLOC_INFO**)ppOut;')
943 hf_body.append(' while (pInNow != NULL)')
944 hf_body.append(' {')
945 hf_body.append(' XGL_MEMORY_ALLOC_INFO** ppOutNow = ppOutNext;')
946 hf_body.append(' ppOutNext = NULL;')
947 hf_body.append('')
948 hf_body.append(' switch (pInNow->sType)')
949 hf_body.append(' {')
950 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:')
951 hf_body.append(' {')
952 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO), pInNow);')
953 hf_body.append(' ppOutNext = (XGL_MEMORY_ALLOC_INFO**)&(*ppOutNow)->pNext;')
954 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
955 hf_body.append(' break;')
956 hf_body.append(' }')
957 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:')
958 hf_body.append(' {')
959 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO), pInNow);')
960 hf_body.append(' ppOutNext = (XGL_MEMORY_ALLOC_INFO**)&(*ppOutNow)->pNext;')
961 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
962 hf_body.append(' break;')
963 hf_body.append(' }')
964 hf_body.append(' default:')
965 hf_body.append(' assert(!"Encountered an unexpected type in memory_alloc_info list");')
966 hf_body.append(' }')
967 hf_body.append(' pInNow = (XGL_MEMORY_ALLOC_INFO*)pInNow->pNext;')
968 hf_body.append(' }')
969 hf_body.append(' return;')
970 hf_body.append('}')
971 hf_body.append('')
Jon Ashburn1751d7a2015-02-10 13:49:30 -0700[diff] [blame]972 hf_body.append('static size_t calculate_memory_barrier_size(uint32_t mbCount, const void** ppMemBarriers)')
973 hf_body.append('{')
974 hf_body.append(' uint32_t i, siz=0;')
975 hf_body.append(' for (i = 0; i < mbCount; i++) {')
976 hf_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) ppMemBarriers[i];')
977 hf_body.append(' switch (pNext->sType) {')
978 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:')
979 hf_body.append(' siz += sizeof(XGL_MEMORY_BARRIER);')
980 hf_body.append(' break;')
981 hf_body.append(' case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:')
982 hf_body.append(' siz += sizeof(XGL_BUFFER_MEMORY_BARRIER);')
983 hf_body.append(' break;')
984 hf_body.append(' case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:')
985 hf_body.append(' siz += sizeof(XGL_IMAGE_MEMORY_BARRIER);')
986 hf_body.append(' break;')
987 hf_body.append(' default:')
988 hf_body.append(' assert(0);')
989 hf_body.append(' break;')
990 hf_body.append(' }')
991 hf_body.append(' }')
992 hf_body.append(' return siz;')
993 hf_body.append('}')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]994 hf_body.append('')
995 hf_body.append('static void add_pipeline_shader_to_trace_packet(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* packetShader, const XGL_PIPELINE_SHADER* paramShader)')
996 hf_body.append('{')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]997 hf_body.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]998 hf_body.append(' // constant buffers')
999 hf_body.append(' if (paramShader->linkConstBufferCount > 0 && paramShader->pLinkConstBufferInfo != NULL)')
1000 hf_body.append(' {')
1001 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo), sizeof(XGL_LINK_CONST_BUFFER) * paramShader->linkConstBufferCount, paramShader->pLinkConstBufferInfo);')
1002 hf_body.append(' for (i = 0; i < paramShader->linkConstBufferCount; i++)')
1003 hf_body.append(' {')
1004 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData), packetShader->pLinkConstBufferInfo[i].bufferSize, paramShader->pLinkConstBufferInfo[i].pBufferData);')
1005 hf_body.append(' }')
1006 hf_body.append(' }')
1007 hf_body.append('}')
1008 hf_body.append('')
1009 hf_body.append('static void finalize_pipeline_shader_address(glv_trace_packet_header* pHeader, const XGL_PIPELINE_SHADER* packetShader)')
1010 hf_body.append('{')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1011 hf_body.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1012 hf_body.append(' // constant buffers')
1013 hf_body.append(' if (packetShader->linkConstBufferCount > 0 && packetShader->pLinkConstBufferInfo != NULL)')
1014 hf_body.append(' {')
1015 hf_body.append(' for (i = 0; i < packetShader->linkConstBufferCount; i++)')
1016 hf_body.append(' {')
1017 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData));')
1018 hf_body.append(' }')
1019 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo));')
1020 hf_body.append(' }')
1021 hf_body.append('}')
1022 hf_body.append('')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1023 hf_body.append('static void add_create_ds_layout_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
1024 hf_body.append('{')
1025 hf_body.append(' const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInNow = pIn;')
1026 hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO** ppOutNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO**)ppOut;')
1027 hf_body.append(' while (pInNow != NULL)')
1028 hf_body.append(' {')
1029 hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO** ppOutNow = ppOutNext;')
1030 hf_body.append(' ppOutNext = NULL;')
1031 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO), pInNow);')
1032 hf_body.append(' ppOutNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO**)&(*ppOutNow)->pNext;')
1033 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1034 hf_body.append(' pInNow = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pInNow->pNext;')
1035 hf_body.append(' }')
1036 hf_body.append(' return;')
1037 hf_body.append('}')
1038 hf_body.append('')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1039 hf_body.append('static void add_update_descriptors_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
1040 hf_body.append('{')
1041 hf_body.append(' const XGL_UPDATE_SAMPLERS* pInNow = pIn;')
1042 hf_body.append(' XGL_UPDATE_SAMPLERS** ppOutNext = (XGL_UPDATE_SAMPLERS**)ppOut;')
1043 hf_body.append(' while (pInNow != NULL)')
1044 hf_body.append(' {')
1045 hf_body.append(' XGL_UPDATE_SAMPLERS** ppOutNow = ppOutNext;')
1046 hf_body.append(' ppOutNext = NULL;')
1047 hf_body.append(' switch (pInNow->sType)')
1048 hf_body.append(' {')
1049 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
1050 hf_body.append(' {')
1051 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_SAMPLERS), pInNow);')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1052 hf_body.append(' XGL_UPDATE_SAMPLERS* pPacket = (XGL_UPDATE_SAMPLERS*)*ppOutNow;')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1053 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplers, ((XGL_UPDATE_SAMPLERS*)pInNow)->count * sizeof(XGL_SAMPLER), ((XGL_UPDATE_SAMPLERS*)pInNow)->pSamplers);')
1054 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplers));')
1055 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1056 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1057 hf_body.append(' break;')
1058 hf_body.append(' }')
1059 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
1060 hf_body.append(' {')
1061 #hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_SAMPLER_TEXTURES) + ((XGL_UPDATE_SAMPLER_TEXTURES*)pNext)->count * (sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO) + sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1062 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_SAMPLER_TEXTURES), pInNow);')
1063 hf_body.append(' XGL_UPDATE_SAMPLER_TEXTURES* pPacket = (XGL_UPDATE_SAMPLER_TEXTURES*)*ppOutNow;')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1064 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplerImageViews, ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->count * sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO), ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->pSamplerImageViews);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1065 # TODO : This is still broken. How to update the original XGL_SAMPLER_IMAGE_VIEW_INFO struct ptrs to have correct address for newly added XGL_IMAGE_VIEW_ATTACH_INFO blocks below?
1066 hf_body.append(' uint32_t i;')
1067 hf_body.append(' for (i = 0; i < ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->count; i++) {')
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1068 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplerImageViews[i].pImageView, sizeof(XGL_IMAGE_VIEW_ATTACH_INFO), ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->pSamplerImageViews[i].pImageView);')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1069 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplerImageViews[i].pImageView));')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1070 hf_body.append(' }')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1071 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplerImageViews));')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1072 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1073 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1074 hf_body.append(' break;')
1075 hf_body.append(' }')
1076 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
1077 hf_body.append(' {')
1078 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_IMAGES), pInNow);')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1079 hf_body.append(' XGL_UPDATE_IMAGES* pPacket = (XGL_UPDATE_IMAGES*)*ppOutNow;')
Jon Ashburn755ad032015-02-04 16:26:30 -0700[diff] [blame]1080 hf_body.append(' uint32_t i;')
1081 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pImageViews, ((XGL_UPDATE_IMAGES*)pInNow)->count * sizeof(XGL_IMAGE_VIEW_ATTACH_INFO *), ((XGL_UPDATE_IMAGES*)pInNow)->pImageViews);')
1082 hf_body.append(' for (i = 0; i < ((XGL_UPDATE_IMAGES*)pInNow)->count; i++) {')
1083 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pImageViews[i], sizeof(XGL_IMAGE_VIEW_ATTACH_INFO), ((XGL_UPDATE_IMAGES*)pInNow)->pImageViews[i]);')
1084 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImageViews[i]));')
1085 hf_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1086 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImageViews));')
1087 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1088 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1089 hf_body.append(' break;')
1090 hf_body.append(' }')
1091 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
1092 hf_body.append(' {')
1093 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_BUFFERS), pInNow);')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1094 hf_body.append(' XGL_UPDATE_BUFFERS* pPacket = (XGL_UPDATE_BUFFERS*)*ppOutNow;')
Jon Ashburn755ad032015-02-04 16:26:30 -0700[diff] [blame]1095 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pBufferViews, ((XGL_UPDATE_BUFFERS*)pInNow)->count * sizeof(XGL_BUFFER_VIEW_ATTACH_INFO *), ((XGL_UPDATE_BUFFERS*)pInNow)->pBufferViews);')
1096 hf_body.append(' uint32_t i;')
1097 hf_body.append(' for (i = 0; i < ((XGL_UPDATE_BUFFERS*)pInNow)->count; i++) {')
1098 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pBufferViews[i], sizeof(XGL_BUFFER_VIEW_ATTACH_INFO), ((XGL_UPDATE_BUFFERS*)pInNow)->pBufferViews[i]);')
1099 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBufferViews[i]));')
1100 hf_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1101 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBufferViews));')
1102 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1103 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1104 hf_body.append(' break;')
1105 hf_body.append(' }')
1106 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
1107 hf_body.append(' {')
1108 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_AS_COPY), pInNow);')
1109 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1110 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1111 hf_body.append(' break;')
1112 hf_body.append(' }')
1113 hf_body.append(' default:')
1114 hf_body.append(' assert(0);')
1115 hf_body.append(' }')
1116 hf_body.append(' pInNow = (XGL_UPDATE_SAMPLERS*)pInNow->pNext;')
1117 hf_body.append(' }')
1118 hf_body.append(' return;')
1119 hf_body.append('}')
1120 hf_body.append('')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1121 pipe_state_list = ['IA_STATE_CREATE_INFO',
1122 'TESS_STATE_CREATE_INFO',
1123 'RS_STATE_CREATE_INFO',
1124 'DS_STATE_CREATE_INFO',
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1125 'VP_STATE_CREATE_INFO',
1126 'MS_STATE_CREATE_INFO'
1127 ]
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1128 hf_body.append('static void add_pipeline_state_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1129 hf_body.append('{')
1130 hf_body.append(' const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInNow = pIn;')
1131 hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)ppOut;')
1132 hf_body.append(' while (pInNow != NULL)')
1133 hf_body.append(' {')
1134 hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNow = ppOutNext;')
1135 hf_body.append(' ppOutNext = NULL;')
1136 hf_body.append('')
1137 hf_body.append(' switch (pInNow->sType)')
1138 hf_body.append(' {')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1139 for pipe_state in pipe_state_list:
1140 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_%s:' % pipe_state)
1141 hf_body.append(' {')
1142 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_%s), pInNow);' % pipe_state)
1143 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1144 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1145 hf_body.append(' break;')
1146 hf_body.append(' }')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1147 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:')
1148 hf_body.append(' {')
1149 hf_body.append(' XGL_PIPELINE_CB_STATE_CREATE_INFO *pPacket = NULL;')
1150 hf_body.append(' XGL_PIPELINE_CB_STATE_CREATE_INFO *pIn = NULL;')
1151 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO), pInNow);')
1152 hf_body.append(' pPacket = (XGL_PIPELINE_CB_STATE_CREATE_INFO*) *ppOutNow;')
1153 hf_body.append(' pIn = (XGL_PIPELINE_CB_STATE_CREATE_INFO*) pInNow;')
1154 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pAttachments, pIn->attachmentCount * sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE), pIn->pAttachments);')
1155 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAttachments));')
1156 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1157 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1158 hf_body.append(' break;')
1159 hf_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1160 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')
1161 hf_body.append(' {')
1162 hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacket = NULL;')
1163 hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInPacket = NULL;')
1164 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO), pInNow);')
1165 hf_body.append(' pPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) *ppOutNow;')
1166 hf_body.append(' pInPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) pInNow;')
1167 hf_body.append(' add_pipeline_shader_to_trace_packet(pHeader, &pPacket->shader, &pInPacket->shader);')
1168 hf_body.append(' finalize_pipeline_shader_address(pHeader, &pPacket->shader);')
1169 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1170 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1171 hf_body.append(' break;')
1172 hf_body.append(' }')
1173 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')
1174 hf_body.append(' {')
1175 hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pPacket = NULL;')
1176 hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pIn = NULL;')
1177 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO), pInNow);')
1178 hf_body.append(' pPacket = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) *ppOutNow;')
1179 hf_body.append(' pIn = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) pInNow;')
1180 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexBindingDescriptions, pIn->bindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION), pIn->pVertexBindingDescriptions);')
1181 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexBindingDescriptions));')
1182 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexAttributeDescriptions, pIn->attributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION), pIn->pVertexAttributeDescriptions);')
1183 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexAttributeDescriptions));')
1184 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1185 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1186 hf_body.append(' break;')
1187 hf_body.append(' }')
1188 hf_body.append(' default:')
1189 hf_body.append(' assert(!"Encountered an unexpected type in pipeline state list");')
1190 hf_body.append(' }')
1191 hf_body.append(' pInNow = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pInNow->pNext;')
1192 hf_body.append(' }')
1193 hf_body.append(' return;')
1194 hf_body.append('}')
1195 return "\n".join(hf_body)
1196
1197 def _generate_packet_id_enum(self):
1198 pid_enum = []
1199 pid_enum.append('enum GLV_TRACE_PACKET_ID_XGL')
1200 pid_enum.append('{')
1201 first_func = True
1202 for proto in self.protos:
1203 if first_func:
1204 first_func = False
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1205 pid_enum.append(' GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,')
1206 pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1207 else:
1208 pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)
1209 pid_enum.append('};\n')
1210 return "\n".join(pid_enum)
1211
1212 def _generate_stringify_func(self):
1213 func_body = []
1214 func_body.append('static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)')
1215 func_body.append('{')
1216 func_body.append(' static char str[1024];')
1217 func_body.append(' switch(id) {')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1218 func_body.append(' case GLV_TPI_XGL_xglApiVersion:')
1219 func_body.append(' {')
1220 func_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)(pHeader->pBody);')
1221 func_body.append(' snprintf(str, 1024, "xglApiVersion = 0x%x", pPacket->version);')
1222 func_body.append(' return str;')
1223 func_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1224 for proto in self.protos:
1225 func_body.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)
1226 func_body.append(' {')
1227 func_str = 'xgl%s(' % proto.name
1228 print_vals = ''
1229 create_func = False
1230 if 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:
1231 create_func = True
1232 for p in proto.params:
1233 last_param = False
1234 if (p.name == proto.params[-1].name):
1235 last_param = True
1236 if last_param and create_func: # last param of create func
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]1237 (pft, pfi, ptr) = self._get_printf_params(p.ty,'pPacket->%s' % p.name, True)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1238 else:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]1239 (pft, pfi, ptr) = self._get_printf_params(p.ty, 'pPacket->%s' % p.name, False)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1240 if last_param == True:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]1241 func_str += '%s%s = %s)' % (ptr, p.name, pft)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1242 print_vals += ', %s' % (pfi)
1243 else:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]1244 func_str += '%s%s = %s, ' % (ptr, p.name, pft)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1245 print_vals += ', %s' % (pfi)
1246 func_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(pHeader->pBody);' % (proto.name, proto.name))
1247 func_body.append(' snprintf(str, 1024, "%s"%s);' % (func_str, print_vals))
1248 func_body.append(' return str;')
1249 func_body.append(' }')
1250 func_body.append(' default:')
1251 func_body.append(' return NULL;')
1252 func_body.append(' }')
1253 func_body.append('};\n')
1254 return "\n".join(func_body)
1255
1256 def _generate_interp_func(self):
1257 interp_func_body = []
1258 interp_func_body.append('static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)')
1259 interp_func_body.append('{')
1260 interp_func_body.append(' if (pHeader == NULL)')
1261 interp_func_body.append(' {')
1262 interp_func_body.append(' return NULL;')
1263 interp_func_body.append(' }')
1264 interp_func_body.append(' switch (pHeader->packet_id)')
1265 interp_func_body.append(' {')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1266 interp_func_body.append(' case GLV_TPI_XGL_xglApiVersion:\n {')
1267 interp_func_body.append(' return interpret_body_as_xglApiVersion(pHeader, TRUE)->header;\n }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1268 for proto in self.protos:
1269 interp_func_body.append(' case GLV_TPI_XGL_xgl%s:\n {' % proto.name)
1270 header_prefix = 'h'
1271 if 'Wsi' in proto.name or 'Dbg' in proto.name:
1272 header_prefix = 'pH'
1273 interp_func_body.append(' return interpret_body_as_xgl%s(pHeader)->%seader;\n }' % (proto.name, header_prefix))
1274 interp_func_body.append(' default:')
1275 interp_func_body.append(' return NULL;')
1276 interp_func_body.append(' }')
1277 interp_func_body.append(' return NULL;')
1278 interp_func_body.append('}')
1279 return "\n".join(interp_func_body)
1280
1281 def _generate_struct_util_funcs(self):
1282 pid_enum = []
1283 pid_enum.append('//=============================================================================')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1284 pid_enum.append('static void add_XGL_APPLICATION_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_APPLICATION_INFO** ppStruct, const XGL_APPLICATION_INFO *pInStruct)')
1285 pid_enum.append('{')
1286 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_APPLICATION_INFO), pInStruct);')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]1287 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen(pInStruct->pAppName) + 1, pInStruct->pAppName);')
1288 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pEngineName), strlen(pInStruct->pEngineName) + 1, pInStruct->pEngineName);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1289 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));')
1290 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')
1291 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);')
1292 pid_enum.append('};\n')
1293 pid_enum.append('//=============================================================================\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1294 pid_enum.append('static void add_XGL_DEVICE_CREATE_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_DEVICE_CREATE_INFO** ppStruct, const XGL_DEVICE_CREATE_INFO *pInStruct)')
1295 pid_enum.append('{')
1296 pid_enum.append(' uint32_t i;')
1297 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_DEVICE_CREATE_INFO), pInStruct);')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]1298 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pRequestedQueues, pInStruct->queueRecordCount*sizeof(XGL_DEVICE_QUEUE_CREATE_INFO), pInStruct->pRequestedQueues);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1299 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);')
1300 pid_enum.append(' if (pInStruct->extensionCount > 0) ')
1301 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1302 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char *), pInStruct->ppEnabledExtensionNames);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1303 pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++)')
1304 pid_enum.append(' {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]1305 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])), strlen(pInStruct->ppEnabledExtensionNames[i]) + 1, pInStruct->ppEnabledExtensionNames[i]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1306 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));')
1307 pid_enum.append(' }')
1308 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
1309 pid_enum.append(' }')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1310 pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) pInStruct->pNext;')
1311 pid_enum.append(' while (pNext != NULL)')
1312 pid_enum.append(' {')
1313 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
1314 pid_enum.append(' {')
1315 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->pNext)), sizeof(XGL_LAYER_CREATE_INFO), pNext);')
1316 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->pNext)));')
1317 pid_enum.append(' XGL_LAYER_CREATE_INFO **ppOutStruct = (XGL_LAYER_CREATE_INFO **) &((*ppStruct)->pNext);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1318 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppOutStruct)->ppActiveLayerNames), pNext->layerCount * sizeof(char *), pNext->ppActiveLayerNames);')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1319 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
1320 pid_enum.append(' {')
1321 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])), strlen(pNext->ppActiveLayerNames[i]) + 1, pNext->ppActiveLayerNames[i]);')
1322 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])));')
1323 pid_enum.append(' }')
1324 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppOutStruct)->ppActiveLayerNames);')
1325 pid_enum.append(' }')
1326 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) pNext->pNext;')
1327 pid_enum.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1328 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')
1329 pid_enum.append('}\n')
1330 pid_enum.append('static XGL_DEVICE_CREATE_INFO* interpret_XGL_DEVICE_CREATE_INFO(glv_trace_packet_header* pHeader, intptr_t ptr_variable)')
1331 pid_enum.append('{')
1332 pid_enum.append(' XGL_DEVICE_CREATE_INFO* pXGL_DEVICE_CREATE_INFO = (XGL_DEVICE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')
1333 pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO != NULL)')
1334 pid_enum.append(' {')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1335 pid_enum.append(' uint32_t i;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1336 pid_enum.append(' const char** pNames;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1337 pid_enum.append(' pXGL_DEVICE_CREATE_INFO->pRequestedQueues = (const XGL_DEVICE_QUEUE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->pRequestedQueues);\n')
1338 pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO->extensionCount > 0)')
1339 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1340 pid_enum.append(' pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames = (const char *const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames);')
1341 pid_enum.append(' pNames = (const char**)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1342 pid_enum.append(' for (i = 0; i < pXGL_DEVICE_CREATE_INFO->extensionCount; i++)')
1343 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1344 pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames[i]));')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1345 pid_enum.append(' }')
1346 pid_enum.append(' }')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1347 pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->pNext);')
1348 pid_enum.append(' while (pNext != NULL)')
1349 pid_enum.append(' {')
1350 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
1351 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1352 pid_enum.append(' pNext->ppActiveLayerNames = (const char**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames));')
1353 pid_enum.append(' pNames = (const char**)pNext->ppActiveLayerNames;')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1354 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
1355 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1356 pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames[i]));')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1357 pid_enum.append(' }')
1358 pid_enum.append(' }')
1359 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);')
1360 pid_enum.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1361 pid_enum.append(' }\n')
1362 pid_enum.append(' return pXGL_DEVICE_CREATE_INFO;')
1363 pid_enum.append('}\n')
1364 pid_enum.append('static void interpret_pipeline_shader(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* pShader)')
1365 pid_enum.append('{')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1366 pid_enum.append(' if (pShader != NULL)')
1367 pid_enum.append(' {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1368 pid_enum.append(' // constant buffers')
1369 pid_enum.append(' if (pShader->linkConstBufferCount > 0)')
1370 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1371 pid_enum.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1372 pid_enum.append(' pShader->pLinkConstBufferInfo = (const XGL_LINK_CONST_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo);')
1373 pid_enum.append(' for (i = 0; i < pShader->linkConstBufferCount; i++)')
1374 pid_enum.append(' {')
1375 pid_enum.append(' XGL_LINK_CONST_BUFFER* pBuffer = (XGL_LINK_CONST_BUFFER*)pShader->pLinkConstBufferInfo;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1376 pid_enum.append(' pBuffer[i].pBufferData = (const void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo[i].pBufferData);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1377 pid_enum.append(' }')
1378 pid_enum.append(' }')
1379 pid_enum.append(' }')
1380 pid_enum.append('}\n')
1381 pid_enum.append('//=============================================================================')
1382 return "\n".join(pid_enum)
1383
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1384 # Interpret functions used on replay to read in packets and interpret their contents
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]1385 # This code gets generated into glvtrace_xgl_xgl_structs.h file
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1386 def _generate_interp_funcs(self):
1387 # Custom txt for given function and parameter. First check if param is NULL, then insert txt if not
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1388 # TODO : This code is now too large and complex, need to make codegen smarter for pointers embedded in struct params to handle those cases automatically
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1389 custom_case_dict = { 'CreateInstance' : {'param': 'pAppInfo', 'txt': ['XGL_APPLICATION_INFO* pInfo = (XGL_APPLICATION_INFO*)pPacket->pAppInfo;\n',
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1390 'pInfo->pAppName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pAppName);\n',
1391 'pInfo->pEngineName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pEngineName);']},
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1392 'CreateShader' : {'param': 'pCreateInfo', 'txt': ['XGL_SHADER_CREATE_INFO* pInfo = (XGL_SHADER_CREATE_INFO*)pPacket->pCreateInfo;\n',
1393 'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
Jon Ashburn8e7dcd02015-02-04 08:50:35 -0700[diff] [blame]1394 'CreateDynamicViewportState' : {'param': 'pCreateInfo', 'txt': ['XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInfo = (XGL_DYNAMIC_VP_STATE_CREATE_INFO*)pPacket->pCreateInfo;\n',
1395 'pInfo->pViewports = (XGL_VIEWPORT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pViewports);\n',
1396 'pInfo->pScissors = (XGL_RECT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pScissors);']},
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1397 'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['XGL_FRAMEBUFFER_CREATE_INFO* pInfo = (XGL_FRAMEBUFFER_CREATE_INFO*)pPacket->pCreateInfo;\n',
1398 'pInfo->pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',
1399 'pInfo->pDepthStencilAttachment = (XGL_DEPTH_STENCIL_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},
1400 'CreateRenderPass' : {'param': 'pCreateInfo', 'txt': ['XGL_RENDER_PASS_CREATE_INFO* pInfo = (XGL_RENDER_PASS_CREATE_INFO*)pPacket->pCreateInfo;\n',
1401 'pInfo->pColorLoadOps = (XGL_ATTACHMENT_LOAD_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadOps);\n',
1402 'pInfo->pColorStoreOps = (XGL_ATTACHMENT_STORE_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorStoreOps);\n',
1403 'pInfo->pColorLoadClearValues = (XGL_CLEAR_COLOR*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadClearValues);\n']},
Jon Ashburnfb3769a2015-02-04 09:32:59 -0700[diff] [blame]1404 'CreateDescriptorRegion' : {'param': 'pCreateInfo', 'txt': ['XGL_DESCRIPTOR_REGION_CREATE_INFO* pInfo = (XGL_DESCRIPTOR_REGION_CREATE_INFO*)pPacket->pCreateInfo;\n',
1405 'pInfo->pTypeCount = (XGL_DESCRIPTOR_TYPE_COUNT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pTypeCount);\n']},
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1406 'CmdWaitEvents' : {'param': 'pWaitInfo', 'txt': ['XGL_EVENT_WAIT_INFO* pInfo = (XGL_EVENT_WAIT_INFO*)pPacket->pWaitInfo;\n',
1407 'pInfo->pEvents = (XGL_EVENT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->pEvents);\n',
1408 'pInfo->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->ppMemBarriers);\n',
1409 'uint32_t i;\n',
1410 'for (i = 0; i < pInfo->memBarrierCount; i++) {\n',
1411 ' void** ppLocalMemBarriers = (void**)&pInfo->ppMemBarriers[i];\n',
1412 ' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->ppMemBarriers[i]);\n',
1413 '}']},
1414 'CmdPipelineBarrier' : {'param': 'pBarrier', 'txt': ['XGL_PIPELINE_BARRIER* pBarrier = (XGL_PIPELINE_BARRIER*)pPacket->pBarrier;\n',
1415 'pBarrier->pEvents = (XGL_SET_EVENT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->pEvents);\n',
1416 'pBarrier->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->ppMemBarriers);\n',
1417 'uint32_t i;\n',
1418 'for (i = 0; i < pBarrier->memBarrierCount; i++) {\n',
1419 ' void** ppLocalMemBarriers = (void**)&pBarrier->ppMemBarriers[i];\n',
1420 ' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pBarrier->ppMemBarriers[i]);\n',
1421 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1422 'CreateDescriptorSetLayout' : {'param': 'pSetLayoutInfoList', 'txt': ['if (pPacket->pSetLayoutInfoList->sType == XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) {\n',
1423 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
1424 ' void** ppNextVoidPtr = (void**)&(pPacket->pSetLayoutInfoList->pNext);\n',
1425 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSetLayoutInfoList->pNext);\n',
1426 ' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pPacket->pSetLayoutInfoList->pNext;\n',
1427 ' while (NULL != pNext)\n', ' {\n',
1428 ' switch(pNext->sType)\n', ' {\n',
1429 ' case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:\n',
1430 ' {\n' ,
1431 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1432 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1433 ' break;\n',
1434 ' }\n',
1435 ' default:\n',
1436 ' {\n',
1437 ' glv_LogError("Encountered an unexpected type in descriptor set layout create list.\\n");\n',
1438 ' pPacket->header = NULL;\n',
1439 ' pNext->pNext = NULL;\n',
1440 ' }\n',
Jon Ashburn7fd7eff2015-02-04 10:55:47 -0700[diff] [blame]1441 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1442 ' pNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pNext->pNext;\n',
1443 ' }\n',
1444 '} else {\n',
1445 ' // This is unexpected.\n',
1446 ' glv_LogError("CreateDescriptorSetLayout must have LayoutInfoList stype of XGL_STRCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO\\n");\n',
1447 ' pPacket->header = NULL;\n',
Jon Ashburn7fd7eff2015-02-04 10:55:47 -0700[diff] [blame]1448 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1449 'BeginCommandBuffer' : {'param': 'pBeginInfo', 'txt': ['if (pPacket->pBeginInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO) {\n',
1450 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
1451 ' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO** ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO**)&(pPacket->pBeginInfo->pNext);\n',
1452 ' *ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBeginInfo->pNext);\n',
1453 ' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pNext = *ppNext;\n',
1454 ' while (NULL != pNext)\n', ' {\n',
1455 ' switch(pNext->sType)\n', ' {\n',
1456 ' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:\n',
1457 ' {\n',
1458 ' ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO**) &pNext->pNext;\n',
1459 ' *ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1460 ' break;\n',
1461 ' }\n',
1462 ' default:\n',
1463 ' {\n',
1464 ' glv_LogError("Encountered an unexpected type in begin command buffer list.\\n");\n',
1465 ' pPacket->header = NULL;\n',
1466 ' pNext->pNext = NULL;\n',
1467 ' }\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1468 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1469 ' pNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pNext->pNext;\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1470 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1471 '} else {\n',
1472 ' // This is unexpected.\n',
1473 ' glv_LogError("BeginCommandBuffer must have BeginInfo stype of XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO.\\n");\n',
1474 ' pPacket->header = NULL;\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1475 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1476 'AllocMemory' : {'param': 'pAllocInfo', 'txt': ['if (pPacket->pAllocInfo->sType == XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO) {\n',
1477 ' XGL_MEMORY_ALLOC_INFO** ppNext = (XGL_MEMORY_ALLOC_INFO**) &(pPacket->pAllocInfo->pNext);\n',
1478 ' *ppNext = (XGL_MEMORY_ALLOC_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAllocInfo->pNext);\n',
1479 ' XGL_MEMORY_ALLOC_INFO* pNext = (XGL_MEMORY_ALLOC_INFO*) *ppNext;\n',
1480 ' while (NULL != pNext)\n', ' {\n',
1481 ' switch(pNext->sType)\n', ' {\n',
1482 ' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:\n',
1483 ' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:\n',
1484 ' {\n',
1485 ' ppNext = (XGL_MEMORY_ALLOC_INFO **) &(pNext->pNext);\n',
1486 ' *ppNext = (XGL_MEMORY_ALLOC_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1487 ' break;\n',
1488 ' }\n',
1489 ' default:\n',
1490 ' {\n',
1491 ' glv_LogError("Encountered an unexpected type alloc memory list.\\n");\n',
1492 ' pPacket->header = NULL;\n',
1493 ' pNext->pNext = NULL;\n',
1494 ' }\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]1495 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1496 ' pNext = (XGL_MEMORY_ALLOC_INFO*)pNext->pNext;\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]1497 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1498 '} else {\n',
1499 ' // This is unexpected.\n',
1500 ' glv_LogError("AllocMemory must have AllocInfo stype of XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO.\\n");\n',
1501 ' pPacket->header = NULL;\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]1502 '}']},
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1503 'UpdateDescriptors' : {'param': 'pUpdateChain', 'txt': ['XGL_UPDATE_SAMPLERS* pNext = (XGL_UPDATE_SAMPLERS*)pPacket->pUpdateChain;\n',
1504 'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
1505 ' switch(pNext->sType)\n', ' {\n',
1506 ' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:\n',
1507 ' {\n',
1508 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1509 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1510 ' break;\n',
1511 ' }\n',
1512 ' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:\n',
1513 ' {\n',
1514 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1515 ' XGL_UPDATE_SAMPLERS* pUS = (XGL_UPDATE_SAMPLERS*)pNext;\n',
1516 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1517 ' pUS->pSamplers = (XGL_SAMPLER*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUS->pSamplers);\n',
1518 ' break;\n',
1519 ' }\n',
1520 ' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:\n',
1521 ' {\n',
1522 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1523 ' XGL_UPDATE_SAMPLER_TEXTURES* pUST = (XGL_UPDATE_SAMPLER_TEXTURES*)pNext;\n',
1524 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1525 ' pUST->pSamplerImageViews = (XGL_SAMPLER_IMAGE_VIEW_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews);\n',
1526 ' uint32_t i;\n',
1527 ' for (i = 0; i < pUST->count; i++) {\n',
1528 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUST->pSamplerImageViews[i].pImageView;\n',
1529 ' *ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews[i].pImageView);\n',
1530 ' }\n',
1531 ' break;\n',
1532 ' }\n',
1533 ' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:\n',
1534 ' {\n',
1535 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1536 ' XGL_UPDATE_IMAGES* pUI = (XGL_UPDATE_IMAGES*)pNext;\n',
1537 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburn755ad032015-02-04 16:26:30 -0700[diff] [blame]1538 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUI->pImageViews;\n',
1539 ' *ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews);\n',
1540 ' uint32_t i;\n',
1541 ' for (i = 0; i < pUI->count; i++) {\n',
1542 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUI->pImageViews[i];\n',
1543 ' *ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews[i]);\n',
1544 ' }\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1545 ' break;\n',
1546 ' }\n',
1547 ' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:\n',
1548 ' {\n',
1549 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1550 ' XGL_UPDATE_BUFFERS* pUB = (XGL_UPDATE_BUFFERS*)pNext;\n',
1551 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburn755ad032015-02-04 16:26:30 -0700[diff] [blame]1552 ' XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferView = (XGL_BUFFER_VIEW_ATTACH_INFO**)&pUB->pBufferViews;\n',
1553 ' *ppLocalBufferView = (XGL_BUFFER_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews);\n',
1554 ' uint32_t i;\n',
1555 ' for (i = 0; i < pUB->count; i++) {\n',
1556 ' XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO**)&pUB->pBufferViews[i];\n',
1557 ' *ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews[i]);\n',
1558 ' }\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1559 ' break;\n',
1560 ' }\n',
1561 ' default:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1562 ' {\n',
1563 ' glv_LogError("Encountered an unexpected type in update descriptors pUpdateChain.\\n");\n',
1564 ' pPacket->header = NULL;\n',
1565 ' pNext->pNext = NULL;\n',
1566 ' }\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1567 ' }\n',
1568 ' pNext = (XGL_UPDATE_SAMPLERS*)pNext->pNext;\n',
1569 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1570 'CreateGraphicsPipeline' : {'param': 'pCreateInfo', 'txt': ['if (pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) {\n',
1571 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
1572 ' void** ppNextVoidPtr = (void**)&pPacket->pCreateInfo->pNext;\n',
1573 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',
1574 ' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n',
1575 ' while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
1576 ' switch(pNext->sType)\n', ' {\n',
1577 ' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',
1578 ' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',
1579 ' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',
1580 ' case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:\n',
1581 ' case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:\n',
1582 ' case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:\n',
1583 ' {\n',
1584 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1585 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1586 ' break;\n',
1587 ' }\n',
1588 ' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',
1589 ' {\n',
1590 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1591 ' XGL_PIPELINE_CB_STATE_CREATE_INFO *pCb = (XGL_PIPELINE_CB_STATE_CREATE_INFO *) pNext;\n',
1592 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1593 ' pCb->pAttachments = (XGL_PIPELINE_CB_ATTACHMENT_STATE*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pCb->pAttachments);\n',
1594 ' break;\n',
1595 ' }\n',
1596 ' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',
1597 ' {\n',
1598 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1599 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1600 ' interpret_pipeline_shader(pHeader, &pNext->shader);\n',
1601 ' break;\n',
1602 ' }\n',
1603 ' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',
1604 ' {\n',
1605 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1606 ' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pVi = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *) pNext;\n',
1607 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1608 ' pVi->pVertexBindingDescriptions = (XGL_VERTEX_INPUT_BINDING_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',
1609 ' pVi->pVertexAttributeDescriptions = (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexAttributeDescriptions);\n',
1610 ' break;\n',
1611 ' }\n',
1612 ' default:\n',
1613 ' {\n',
1614 ' glv_LogError("Encountered an unexpected type in pipeline state list.\\n");\n',
1615 ' pPacket->header = NULL;\n',
1616 ' pNext->pNext = NULL;\n',
1617 ' }\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1618 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1619 ' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1620 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1621 '} else {\n',
1622 ' // This is unexpected.\n',
1623 ' glv_LogError("CreateGraphicsPipeline must have CreateInfo stype of XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO.\\n");\n',
1624 ' pPacket->header = NULL;\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1625 '}']},
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1626 'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_pipeline_shader(pHeader, (XGL_PIPELINE_SHADER*)(&pPacket->pCreateInfo->cs));']}}
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1627 if_body = []
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1628 if_body.append('typedef struct struct_xglApiVersion {')
1629 if_body.append(' glv_trace_packet_header* header;')
1630 if_body.append(' uint32_t version;')
1631 if_body.append('} struct_xglApiVersion;\n')
1632 if_body.append('static struct_xglApiVersion* interpret_body_as_xglApiVersion(glv_trace_packet_header* pHeader, BOOL check_version)')
1633 if_body.append('{')
1634 if_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)pHeader->pBody;')
1635 if_body.append(' pPacket->header = pHeader;')
1636 if_body.append(' if (check_version && pPacket->version != XGL_API_VERSION)')
1637 if_body.append(' glv_LogError("Trace file from older XGL version 0x%x, xgl replayer built from version 0x%x, replayer may fail\\n", pPacket->version, XGL_API_VERSION);')
1638 if_body.append(' return pPacket;')
1639 if_body.append('}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1640 for proto in self.protos:
1641 if 'Wsi' not in proto.name and 'Dbg' not in proto.name:
1642 if 'UnmapMemory' == proto.name:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1643 proto.params.append(xgl.Param("void*", "pData"))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1644 if_body.append('typedef struct struct_xgl%s {' % proto.name)
1645 if_body.append(' glv_trace_packet_header* header;')
1646 for p in proto.params:
1647 if '[4]' in p.ty:
1648 if_body.append(' %s %s[4];' % (p.ty.strip('[4]'), p.name))
1649 else:
1650 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1651 if 'void' != proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1652 if_body.append(' %s result;' % proto.ret)
1653 if_body.append('} struct_xgl%s;\n' % proto.name)
1654 if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
1655 if_body.append('{')
1656 if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))
1657 if_body.append(' pPacket->header = pHeader;')
1658 for p in proto.params:
1659 if '*' in p.ty:
1660 if 'DEVICE_CREATE_INFO' in p.ty:
1661 if_body.append(' pPacket->%s = interpret_XGL_DEVICE_CREATE_INFO(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))
1662 else:
1663 if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]1664 # TODO : Generalize this custom code to kill dict data struct above.
1665 # Really the point of this block is to catch params w/ embedded ptrs to structs and chains of structs
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1666 if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:
1667 if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])
1668 if_body.append(' {')
1669 if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))
1670 if_body.append(' }')
1671 if_body.append(' return pPacket;')
1672 if_body.append('}\n')
1673 return "\n".join(if_body)
1674
1675 def _generate_interp_funcs_ext(self, func_class='Wsi'):
1676 if_body = []
1677 for proto in self.protos:
1678 if func_class in proto.name:
1679 if_body.append('typedef struct struct_xgl%s {' % proto.name)
1680 if_body.append(' glv_trace_packet_header* pHeader;')
1681 for p in proto.params:
1682 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1683 if 'void' != proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1684 if_body.append(' %s result;' % proto.ret)
1685 if_body.append('} struct_xgl%s;\n' % proto.name)
1686 if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
1687 if_body.append('{')
1688 if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))
1689 if_body.append(' pPacket->pHeader = pHeader;')
1690 for p in proto.params:
1691 if '*' in p.ty:
1692 if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
1693 if_body.append(' return pPacket;')
1694 if_body.append('}\n')
1695 return "\n".join(if_body)
1696
1697 def _generate_replay_class_decls(self):
1698 cd_body = []
1699 cd_body.append('class ApiReplay {')
1700 cd_body.append('public:')
1701 cd_body.append(' virtual ~ApiReplay() { }')
1702 cd_body.append(' virtual enum glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header * packet) = 0;')
1703 cd_body.append(' virtual int init(glv_replay::Display & disp) = 0;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1704 cd_body.append(' virtual void push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char* pMsg) = 0;')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1705 cd_body.append(' virtual glv_replay::GLV_REPLAY_RESULT pop_validation_msgs() = 0;')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]1706 cd_body.append(' virtual int dump_validation_data() = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1707 cd_body.append('};\n')
1708 cd_body.append('class xglDisplay: public glv_replay::DisplayImp {')
1709 cd_body.append('friend class xglReplay;')
1710 cd_body.append('public:')
1711 cd_body.append(' xglDisplay();')
1712 cd_body.append(' ~xglDisplay();')
1713 cd_body.append(' int init(const unsigned int gpu_idx);')
1714 cd_body.append(' int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height);')
1715 cd_body.append(' int create_window(const unsigned int width, const unsigned int height);')
1716 cd_body.append(' void resize_window(const unsigned int width, const unsigned int height);')
1717 cd_body.append(' void process_event();')
1718 cd_body.append(' // XGL_DEVICE get_device() { return m_dev[m_gpuIdx];}')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]1719 cd_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1720 cd_body.append(' xcb_window_t get_window_handle() { return m_XcbWindow; }')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]1721 cd_body.append('#elif defined(WIN32)')
1722 cd_body.append(' HWND get_window_handle() { return m_windowHandle; }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1723 cd_body.append('#endif')
1724 cd_body.append('private:')
1725 cd_body.append(' XGL_RESULT init_xgl(const unsigned int gpu_idx);')
1726 cd_body.append(' bool m_initedXGL;')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]1727 cd_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1728 cd_body.append(' XGL_WSI_X11_CONNECTION_INFO m_WsiConnection;')
1729 cd_body.append(' xcb_screen_t *m_pXcbScreen;')
1730 cd_body.append(' xcb_window_t m_XcbWindow;')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]1731 cd_body.append('#elif defined(WIN32)')
1732 cd_body.append(' HWND m_windowHandle;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1733 cd_body.append('#endif')
1734 cd_body.append(' unsigned int m_windowWidth;')
1735 cd_body.append(' unsigned int m_windowHeight;')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]1736 cd_body.append(' unsigned int m_frameNumber;')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]1737 cd_body.append(' std::vector<uint32_t> imageWidth;')
1738 cd_body.append(' std::vector<uint32_t> imageHeight;')
1739 cd_body.append(' std::vector<XGL_IMAGE> imageHandles;')
1740 cd_body.append(' std::vector<XGL_GPU_MEMORY> imageMemory;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1741 cd_body.append('#if 0')
1742 cd_body.append(' XGL_DEVICE m_dev[XGL_MAX_PHYSICAL_GPUS];')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1743 cd_body.append(' uint32_t m_gpuCount;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1744 cd_body.append(' unsigned int m_gpuIdx;')
1745 cd_body.append(' XGL_PHYSICAL_GPU m_gpus[XGL_MAX_PHYSICAL_GPUS];')
1746 cd_body.append(' XGL_PHYSICAL_GPU_PROPERTIES m_gpuProps[XGL_MAX_PHYSICAL_GPUS];')
1747 cd_body.append('#endif')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1748 cd_body.append(' std::vector<char *>m_extensions;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1749 cd_body.append('};\n')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1750 cd_body.append('class objMemory {')
1751 cd_body.append('public:')
1752 cd_body.append(' objMemory() : m_numAllocations(0), m_pMemReqs(NULL) {}')
1753 cd_body.append(' ~objMemory() { free(m_pMemReqs);}')
1754 cd_body.append(' void setCount(const uint32_t num);')
1755 cd_body.append(' void setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num);')
1756 cd_body.append('private:')
1757 cd_body.append(' uint32_t m_numAllocations;')
1758 cd_body.append(' XGL_MEMORY_REQUIREMENTS *m_pMemReqs;')
1759 cd_body.append('};\n')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]1760 cd_body.append('class gpuMemory {')
1761 cd_body.append('public:')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]1762 cd_body.append(' gpuMemory() : m_pendingAlloc(false) {m_allocInfo.allocationSize = 0;}')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]1763 cd_body.append(' ~gpuMemory() {}')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]1764 cd_body.append(' bool isPendingAlloc();')
1765 cd_body.append(' void setAllocInfo(const XGL_MEMORY_ALLOC_INFO *info, const bool pending);')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]1766 cd_body.append(' void setMemoryDataAddr(void *pBuf);')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]1767 cd_body.append(' void setMemoryMapRange(void *pBuf, const size_t size, const size_t offset, const bool pending);')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]1768 cd_body.append(' void copyMappingData(const void *pSrcData);')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]1769 cd_body.append(' size_t getMemoryMapSize();')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]1770 cd_body.append('private:')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]1771 cd_body.append(' bool m_pendingAlloc;')
1772 cd_body.append(' struct mapRange {')
1773 cd_body.append(' bool pending;')
1774 cd_body.append(' size_t size;')
1775 cd_body.append(' size_t offset;')
1776 cd_body.append(' void *pData;')
1777 cd_body.append(' };')
1778 cd_body.append(' std::vector<struct mapRange> m_mapRange;')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]1779 cd_body.append(' XGL_MEMORY_ALLOC_INFO m_allocInfo;')
1780 cd_body.append('};\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1781 return "\n".join(cd_body)
1782
1783 def _generate_replay_func_ptrs(self):
1784 xf_body = []
1785 xf_body.append('struct xglFuncs {')
1786 xf_body.append(' void init_funcs(void * libHandle);')
1787 xf_body.append(' void *m_libHandle;\n')
1788 for proto in self.protos:
1789 xf_body.append(' typedef %s( XGLAPI * type_xgl%s)(' % (proto.ret, proto.name))
1790 for p in proto.params:
1791 if '[4]' in p.ty:
1792 xf_body.append(' %s %s[4],' % (p.ty.strip('[4]'), p.name))
1793 else:
1794 xf_body.append(' %s %s,' % (p.ty, p.name))
1795 xf_body[-1] = xf_body[-1].replace(',', ');')
1796 xf_body.append(' type_xgl%s real_xgl%s;' % (proto.name, proto.name))
1797 xf_body.append('};')
1798 return "\n".join(xf_body)
1799
1800 def _map_decl(self, type1, type2, name):
1801 return ' std::map<%s, %s> %s;' % (type1, type2, name)
1802
1803 def _add_to_map_decl(self, type1, type2, name):
1804 txt = ' void add_to_map(%s* pTraceVal, %s* pReplayVal)\n {\n' % (type1, type2)
1805 txt += ' assert(pTraceVal != NULL);\n'
1806 txt += ' assert(pReplayVal != NULL);\n'
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1807 txt += ' %s[*pTraceVal] = *pReplayVal;\n }\n' % name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1808 return txt
1809
1810 def _rm_from_map_decl(self, ty, name):
1811 txt = ' void rm_from_map(const %s& key)\n {\n' % (ty)
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1812 txt += ' %s.erase(key);\n }\n' % name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1813 return txt
1814
1815 def _remap_decl(self, ty, name):
1816 txt = ' %s remap(const %s& value)\n {\n' % (ty, ty)
1817 txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1818 txt += ' return (q == %s.end()) ? XGL_NULL_HANDLE : q->second;\n }\n' % name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1819 return txt
1820
1821 def _generate_replay_class(self):
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1822 # Create dict mapping member var names to XGL type (i.e. 'm_imageViews' : 'XGL_IMAGE_VIEW')
1823 obj_map_dict = {}
1824 for ty in xgl.object_type_list:
1825 if ty in xgl.object_parent_list:
1826 continue
1827 mem_var = ty.replace('XGL_', '').lower()
1828 mem_var_list = mem_var.split('_')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1829 mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))
1830 obj_map_dict[mem_var] = ty
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1831 rc_body = []
1832 rc_body.append('class xglReplay : public ApiReplay {')
1833 rc_body.append('public:')
1834 rc_body.append(' ~xglReplay();')
Ian Elliott91e681e2015-02-18 15:35:00 -0700[diff] [blame]1835 rc_body.append(' xglReplay(glvreplay_settings *pReplaySettings);\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1836 rc_body.append(' int init(glv_replay::Display & disp);')
1837 rc_body.append(' xglDisplay * get_display() {return m_display;}')
1838 rc_body.append(' glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header *packet);')
1839 rc_body.append(' glv_replay::GLV_REPLAY_RESULT handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn);\n')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1840 rc_body.append(' void push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char* pMsg);')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1841 rc_body.append(' glv_replay::GLV_REPLAY_RESULT pop_validation_msgs();')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]1842 rc_body.append(' int dump_validation_data();')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1843 rc_body.append('private:')
1844 rc_body.append(' struct xglFuncs m_xglFuncs;')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]1845 rc_body.append(' DRAW_STATE_DUMP_DOT_FILE m_pDSDump;')
Jeremy Hayes7ec63022015-02-26 15:59:19 -0700[diff] [blame]1846 rc_body.append(' DRAW_STATE_DUMP_COMMAND_BUFFER_DOT_FILE m_pCBDump;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1847 rc_body.append(' xglDisplay *m_display;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1848 rc_body.append(' struct shaderPair {')
1849 rc_body.append(' XGL_SHADER *addr;')
1850 rc_body.append(' XGL_SHADER val;')
1851 rc_body.append(' };')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1852 rc_body.append(' struct validationMsg {')
1853 rc_body.append(' XGL_VALIDATION_LEVEL validationLevel;')
1854 rc_body.append(' XGL_BASE_OBJECT srcObject;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1855 rc_body.append(' size_t location;')
1856 rc_body.append(' int32_t msgCode;')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1857 rc_body.append(' char msg[256];')
1858 rc_body.append(' };')
1859 rc_body.append(' std::vector<struct validationMsg> m_validationMsgs;')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]1860 rc_body.append(' std::vector<int> m_screenshotFrames;')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1861 rc_body.append(' bool m_adjustForGPU; // true if replay adjusts behavior based on GPU')
1862 # Code for memory objects for handling replay GPU != trace GPU object memory requirements
1863 rc_body.append(' struct imageObj {')
1864 rc_body.append(' objMemory imageMem;')
1865 rc_body.append(' XGL_IMAGE replayImage;')
1866 rc_body.append(' };\n')
1867 rc_body.append(' struct bufferObj {')
1868 rc_body.append(' objMemory bufferMem;')
1869 rc_body.append(' XGL_BUFFER replayBuffer;')
1870 rc_body.append(' };\n')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1871 rc_body.append(' struct gpuMemObj {')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]1872 rc_body.append(' gpuMemory *pGpuMem;')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1873 rc_body.append(' XGL_GPU_MEMORY replayGpuMem;')
1874 rc_body.append(' };\n')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1875 rc_body.append(' void init_objMemCount(const XGL_BASE_OBJECT& object, const uint32_t &num)\n {')
1876 rc_body.append(' XGL_IMAGE img = static_cast <XGL_IMAGE> (object);')
1877 rc_body.append(' std::map<XGL_IMAGE, struct imageObj>::const_iterator it = m_images.find(img);')
1878 rc_body.append(' if (it != m_images.end())')
1879 rc_body.append(' {')
1880 rc_body.append(' objMemory obj = it->second.imageMem;')
1881 rc_body.append(' obj.setCount(num);')
1882 rc_body.append(' return;')
1883 rc_body.append(' }')
1884 rc_body.append(' XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);')
1885 rc_body.append(' std::map<XGL_BUFFER, struct bufferObj>::const_iterator itb = m_buffers.find(buf);')
1886 rc_body.append(' if (itb != m_buffers.end())')
1887 rc_body.append(' {')
1888 rc_body.append(' objMemory obj = itb->second.bufferMem;')
1889 rc_body.append(' obj.setCount(num);')
1890 rc_body.append(' return;')
1891 rc_body.append(' }')
1892 rc_body.append(' return;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1893 rc_body.append(' }\n')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1894 rc_body.append(' void init_objMemReqs(const XGL_BASE_OBJECT& object, const XGL_MEMORY_REQUIREMENTS *pMemReqs, const unsigned int num)\n {')
1895 rc_body.append(' XGL_IMAGE img = static_cast <XGL_IMAGE> (object);')
1896 rc_body.append(' std::map<XGL_IMAGE, struct imageObj>::const_iterator it = m_images.find(img);')
1897 rc_body.append(' if (it != m_images.end())')
1898 rc_body.append(' {')
1899 rc_body.append(' objMemory obj = it->second.imageMem;')
1900 rc_body.append(' obj.setReqs(pMemReqs, num);')
1901 rc_body.append(' return;')
1902 rc_body.append(' }')
1903 rc_body.append(' XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);')
1904 rc_body.append(' std::map<XGL_BUFFER, struct bufferObj>::const_iterator itb = m_buffers.find(buf);')
1905 rc_body.append(' if (itb != m_buffers.end())')
1906 rc_body.append(' {')
1907 rc_body.append(' objMemory obj = itb->second.bufferMem;')
1908 rc_body.append(' obj.setReqs(pMemReqs, num);')
1909 rc_body.append(' return;')
1910 rc_body.append(' }')
1911 rc_body.append(' return;')
1912 rc_body.append(' }\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1913 rc_body.append(' void clear_all_map_handles()\n {')
1914 for var in sorted(obj_map_dict):
1915 rc_body.append(' %s.clear();' % var)
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1916 rc_body.append(' }\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1917 for var in sorted(obj_map_dict):
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1918 if obj_map_dict[var] == 'XGL_IMAGE':
1919 rc_body.append(self._map_decl(obj_map_dict[var], 'struct imageObj', var))
1920 rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'struct imageObj', var))
1921 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1922 rc_body.append(' XGL_IMAGE remap(const XGL_IMAGE& value)')
1923 rc_body.append(' {')
1924 rc_body.append(' std::map<XGL_IMAGE, struct imageObj>::const_iterator q = m_images.find(value);')
1925 rc_body.append(' return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second.replayImage;')
1926 rc_body.append(' }\n')
1927 elif obj_map_dict[var] == 'XGL_BUFFER':
1928 rc_body.append(self._map_decl(obj_map_dict[var], 'struct bufferObj', var))
1929 rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'struct bufferObj', var))
1930 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1931 rc_body.append(' XGL_BUFFER remap(const XGL_BUFFER& value)')
1932 rc_body.append(' {')
1933 rc_body.append(' std::map<XGL_BUFFER, struct bufferObj>::const_iterator q = m_buffers.find(value);')
1934 rc_body.append(' return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second.replayBuffer;')
1935 rc_body.append(' }\n')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1936 elif obj_map_dict[var] == 'XGL_GPU_MEMORY':
1937 rc_body.append(self._map_decl(obj_map_dict[var], 'struct gpuMemObj', var))
1938 rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'struct gpuMemObj', var))
1939 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1940 rc_body.append(' XGL_GPU_MEMORY remap(const XGL_GPU_MEMORY& value)')
1941 rc_body.append(' {')
1942 rc_body.append(' std::map<XGL_GPU_MEMORY, struct gpuMemObj>::const_iterator q = m_gpuMemorys.find(value);')
1943 rc_body.append(' return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second.replayGpuMem;')
1944 rc_body.append(' }\n')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1945 else:
1946 rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))
1947 rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))
1948 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1949 rc_body.append(self._remap_decl(obj_map_dict[var], var))
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1950 # XGL_DYNAMIC_STATE_OBJECT code
1951 state_obj_remap_types = xgl.object_dynamic_state_list
1952 rc_body.append(' XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
1953 rc_body.append(' XGL_DYNAMIC_STATE_OBJECT obj;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1954 for t in state_obj_remap_types:
1955 rc_body.append(' if ((obj = remap(static_cast <%s> (state))) != XGL_NULL_HANDLE)' % t)
1956 rc_body.append(' return obj;')
1957 rc_body.append(' return XGL_NULL_HANDLE;\n }')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1958 rc_body.append(' void rm_from_map(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1959 for t in state_obj_remap_types:
1960 rc_body.append(' rm_from_map(static_cast <%s> (state));' % t)
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1961 rc_body.append(' }\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1962 # OBJECT code
1963 rc_body.append(' XGL_OBJECT remap(const XGL_OBJECT& object)\n {')
1964 rc_body.append(' XGL_OBJECT obj;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1965 obj_remap_types = xgl.object_list
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1966 for var in obj_remap_types:
1967 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % (var))
1968 rc_body.append(' return obj;')
1969 rc_body.append(' return XGL_NULL_HANDLE;\n }')
1970 rc_body.append(' void rm_from_map(const XGL_OBJECT & objKey)\n {')
1971 for var in obj_remap_types:
1972 rc_body.append(' rm_from_map(static_cast <%s> (objKey));' % (var))
1973 rc_body.append(' }')
1974 rc_body.append(' XGL_BASE_OBJECT remap(const XGL_BASE_OBJECT& object)\n {')
1975 rc_body.append(' XGL_BASE_OBJECT obj;')
1976 base_obj_remap_types = ['XGL_DEVICE', 'XGL_QUEUE', 'XGL_GPU_MEMORY', 'XGL_OBJECT']
1977 for t in base_obj_remap_types:
1978 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % t)
1979 rc_body.append(' return obj;')
1980 rc_body.append(' return XGL_NULL_HANDLE;\n }')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]1981 rc_body.append('void process_screenshot_list(const char *list)')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]1982 rc_body.append('{')
1983 rc_body.append(' std::string spec(list), word;')
1984 rc_body.append(' size_t start = 0, comma = 0;\n')
1985 rc_body.append(' while (start < spec.size()) {')
1986 rc_body.append(' comma = spec.find(\',\', start);\n')
1987 rc_body.append(' if (comma == std::string::npos)')
1988 rc_body.append(' word = std::string(spec, start);')
1989 rc_body.append(' else')
1990 rc_body.append(' word = std::string(spec, start, comma - start);\n')
Tony Barboure3c27be2015-02-05 13:55:03 -0700[diff] [blame]1991 rc_body.append(' m_screenshotFrames.push_back(atoi(word.c_str()));')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]1992 rc_body.append(' if (comma == std::string::npos)')
1993 rc_body.append(' break;\n')
1994 rc_body.append(' start = comma + 1;\n')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]1995 rc_body.append(' }')
1996 rc_body.append('}')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1997 rc_body.append('};')
1998 return "\n".join(rc_body)
1999
2000 def _generate_replay_display_init_xgl(self):
2001 dix_body = []
2002 dix_body.append('XGL_RESULT xglDisplay::init_xgl(unsigned int gpu_idx)')
2003 dix_body.append('{')
2004 dix_body.append('#if 0')
2005 dix_body.append(' XGL_APPLICATION_INFO appInfo = {};')
2006 dix_body.append(' appInfo.pAppName = APP_NAME;')
2007 dix_body.append(' appInfo.pEngineName = "";')
2008 dix_body.append(' appInfo.apiVersion = XGL_API_VERSION;')
2009 dix_body.append(' XGL_RESULT res = xglInitAndEnumerateGpus(&appInfo, NULL, XGL_MAX_PHYSICAL_GPUS, &m_gpuCount, m_gpus);')
2010 dix_body.append(' if ( res == XGL_SUCCESS ) {')
2011 dix_body.append(' // retrieve the GPU information for all GPUs')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2012 dix_body.append(' for( uint32_t gpu = 0; gpu < m_gpuCount; gpu++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2013 dix_body.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2014 dix_body.append(' size_t gpuInfoSize = sizeof(m_gpuProps[0]);\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2015 dix_body.append(' // get the GPU physical properties:')
2016 dix_body.append(' res = xglGetGpuInfo( m_gpus[gpu], XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &gpuInfoSize, &m_gpuProps[gpu]);')
2017 dix_body.append(' if (res != XGL_SUCCESS)')
2018 dix_body.append(' glv_LogWarn("Failed to retrieve properties for gpu[%d] result %d\\n", gpu, res);')
2019 dix_body.append(' }')
2020 dix_body.append(' res = XGL_SUCCESS;')
2021 dix_body.append(' } else if ((gpu_idx + 1) > m_gpuCount) {')
2022 dix_body.append(' glv_LogError("xglInitAndEnumerate number of gpus does not include requested index: num %d, requested %d\\n", m_gpuCount, gpu_idx);')
2023 dix_body.append(' return -1;')
2024 dix_body.append(' } else {')
2025 dix_body.append(' glv_LogError("xglInitAndEnumerate failed\\n");')
2026 dix_body.append(' return res;')
2027 dix_body.append(' }')
2028 dix_body.append(' // TODO add multi-gpu support always use gpu[gpu_idx] for now')
2029 dix_body.append(' // get all extensions supported by this device gpu[gpu_idx]')
2030 dix_body.append(' // first check if extensions are available and save a list of them')
2031 dix_body.append(' bool foundWSIExt = false;')
2032 dix_body.append(' for( int ext = 0; ext < sizeof( extensions ) / sizeof( extensions[0] ); ext++)')
2033 dix_body.append(' {')
2034 dix_body.append(' res = xglGetExtensionSupport( m_gpus[gpu_idx], extensions[ext] );')
2035 dix_body.append(' if (res == XGL_SUCCESS) {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2036 dix_body.append(' m_extensions.push_back((char *) extensions[ext]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2037 dix_body.append(' if (!strcmp(extensions[ext], "XGL_WSI_WINDOWS"))')
2038 dix_body.append(' foundWSIExt = true;')
2039 dix_body.append(' }')
2040 dix_body.append(' }')
2041 dix_body.append(' if (!foundWSIExt) {')
2042 dix_body.append(' glv_LogError("XGL_WSI_WINDOWS extension not supported by gpu[%d]\\n", gpu_idx);')
2043 dix_body.append(' return XGL_ERROR_INCOMPATIBLE_DEVICE;')
2044 dix_body.append(' }')
2045 dix_body.append(' // TODO generalize this: use one universal queue for now')
2046 dix_body.append(' XGL_DEVICE_QUEUE_CREATE_INFO dqci = {};')
2047 dix_body.append(' dqci.queueCount = 1;')
2048 dix_body.append(' dqci.queueType = XGL_QUEUE_UNIVERSAL;')
2049 dix_body.append(' // create the device enabling validation level 4')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2050 dix_body.append(' const char * const * extNames = &m_extensions[0];')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2051 dix_body.append(' XGL_DEVICE_CREATE_INFO info = {};')
2052 dix_body.append(' info.queueRecordCount = 1;')
2053 dix_body.append(' info.pRequestedQueues = &dqci;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2054 dix_body.append(' info.extensionCount = static_cast <uint32_t> (m_extensions.size());')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2055 dix_body.append(' info.ppEnabledExtensionNames = extNames;')
2056 dix_body.append(' info.flags = XGL_DEVICE_CREATE_VALIDATION;')
2057 dix_body.append(' info.maxValidationLevel = XGL_VALIDATION_LEVEL_4;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2058 dix_body.append(' bool32_t xglTrue = XGL_TRUE;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2059 dix_body.append(' res = xglDbgSetGlobalOption( XGL_DBG_OPTION_BREAK_ON_ERROR, sizeof( xglTrue ), &xglTrue );')
2060 dix_body.append(' if (res != XGL_SUCCESS)')
2061 dix_body.append(' glv_LogWarn("Could not set debug option break on error\\n");')
2062 dix_body.append(' res = xglCreateDevice( m_gpus[0], &info, &m_dev[gpu_idx]);')
2063 dix_body.append(' return res;')
2064 dix_body.append('#else')
2065 dix_body.append(' return XGL_ERROR_INITIALIZATION_FAILED;')
2066 dix_body.append('#endif')
2067 dix_body.append('}')
2068 return "\n".join(dix_body)
2069
2070 def _generate_replay_display_init(self):
2071 di_body = []
2072 di_body.append('int xglDisplay::init(const unsigned int gpu_idx)')
2073 di_body.append('{')
2074 di_body.append(' //m_gpuIdx = gpu_idx;')
2075 di_body.append('#if 0')
2076 di_body.append(' XGL_RESULT result = init_xgl(gpu_idx);')
2077 di_body.append(' if (result != XGL_SUCCESS) {')
2078 di_body.append(' glv_LogError("could not init xgl library");')
2079 di_body.append(' return -1;')
2080 di_body.append(' } else {')
2081 di_body.append(' m_initedXGL = true;')
2082 di_body.append(' }')
2083 di_body.append('#endif')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2084 di_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2085 di_body.append(' const xcb_setup_t *setup;')
2086 di_body.append(' xcb_screen_iterator_t iter;')
2087 di_body.append(' int scr;')
2088 di_body.append(' xcb_connection_t *pConnection;')
2089 di_body.append(' pConnection = xcb_connect(NULL, &scr);')
2090 di_body.append(' setup = xcb_get_setup(pConnection);')
2091 di_body.append(' iter = xcb_setup_roots_iterator(setup);')
2092 di_body.append(' while (scr-- > 0)')
2093 di_body.append(' xcb_screen_next(&iter);')
2094 di_body.append(' m_pXcbScreen = iter.data;')
2095 di_body.append(' m_WsiConnection.pConnection = pConnection;')
2096 di_body.append(' m_WsiConnection.root = m_pXcbScreen->root;')
2097 di_body.append('#endif')
2098 di_body.append(' return 0;')
2099 di_body.append('}')
2100 return "\n".join(di_body)
2101
2102 def _generate_replay_display_structors(self):
2103 ds_body = []
2104 ds_body.append('xglDisplay::xglDisplay()')
2105 ds_body.append(' : m_initedXGL(false),')
2106 ds_body.append(' m_windowWidth(0),')
2107 ds_body.append(' m_windowHeight(0)')
2108 ds_body.append('{')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2109 ds_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2110 ds_body.append(' m_WsiConnection.pConnection = NULL;')
2111 ds_body.append(' m_WsiConnection.root = 0;')
2112 ds_body.append(' m_WsiConnection.provider = 0;')
2113 ds_body.append(' m_pXcbScreen = NULL;')
2114 ds_body.append(' m_XcbWindow = 0;')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2115 ds_body.append('#elif defined(WIN32)')
2116 ds_body.append(' m_windowHandle = NULL;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2117 ds_body.append('#endif')
2118 ds_body.append('}')
2119 ds_body.append('xglDisplay::~xglDisplay()')
2120 ds_body.append('{')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2121 ds_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2122 ds_body.append(' if (m_XcbWindow != 0)')
2123 ds_body.append(' {')
2124 ds_body.append(' xcb_destroy_window(m_WsiConnection.pConnection, m_XcbWindow);')
2125 ds_body.append(' }')
2126 ds_body.append(' if (m_WsiConnection.pConnection != NULL)')
2127 ds_body.append(' {')
2128 ds_body.append(' xcb_disconnect(m_WsiConnection.pConnection);')
2129 ds_body.append(' }')
2130 ds_body.append('#endif')
2131 ds_body.append('}')
2132 return "\n".join(ds_body)
2133
2134 def _generate_replay_display_window(self):
2135 dw_body = []
2136 dw_body.append('#if defined(WIN32)')
2137 dw_body.append('LRESULT WINAPI WindowProcXgl( HWND window, unsigned int msg, WPARAM wp, LPARAM lp)')
2138 dw_body.append('{')
2139 dw_body.append(' switch(msg)')
2140 dw_body.append(' {')
2141 dw_body.append(' case WM_CLOSE:')
2142 dw_body.append(' DestroyWindow( window);')
2143 dw_body.append(' // fall-thru')
2144 dw_body.append(' case WM_DESTROY:')
2145 dw_body.append(' PostQuitMessage(0) ;')
2146 dw_body.append(' return 0L ;')
2147 dw_body.append(' default:')
2148 dw_body.append(' return DefWindowProc( window, msg, wp, lp ) ;')
2149 dw_body.append(' }')
2150 dw_body.append('}')
2151 dw_body.append('#endif')
2152 dw_body.append('int xglDisplay::set_window(glv_window_handle hWindow, unsigned int width, unsigned int height)')
2153 dw_body.append('{')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2154 dw_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2155 dw_body.append(' m_XcbWindow = hWindow;')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2156 dw_body.append('#elif defined(WIN32)')
2157 dw_body.append(' m_windowHandle = hWindow;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2158 dw_body.append('#endif')
2159 dw_body.append(' m_windowWidth = width;')
2160 dw_body.append(' m_windowHeight = height;')
2161 dw_body.append(' return 0;')
2162 dw_body.append('}\n')
2163 dw_body.append('int xglDisplay::create_window(const unsigned int width, const unsigned int height)')
2164 dw_body.append('{')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2165 dw_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)\n')
2166 dw_body.append(' uint32_t value_mask, value_list[32];')
2167 dw_body.append(' m_XcbWindow = xcb_generate_id(m_WsiConnection.pConnection);\n')
2168 dw_body.append(' value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;')
2169 dw_body.append(' value_list[0] = m_pXcbScreen->black_pixel;')
2170 dw_body.append(' value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |')
2171 dw_body.append(' XCB_EVENT_MASK_EXPOSURE;\n')
2172 dw_body.append(' xcb_create_window(m_WsiConnection.pConnection,')
2173 dw_body.append(' XCB_COPY_FROM_PARENT,')
2174 dw_body.append(' m_XcbWindow, m_WsiConnection.root,')
2175 dw_body.append(' 0, 0, width, height, 0,')
2176 dw_body.append(' XCB_WINDOW_CLASS_INPUT_OUTPUT,')
2177 dw_body.append(' m_pXcbScreen->root_visual,')
2178 dw_body.append(' value_mask, value_list);\n')
2179 dw_body.append(' xcb_map_window(m_WsiConnection.pConnection, m_XcbWindow);')
2180 dw_body.append(' xcb_flush(m_WsiConnection.pConnection);')
2181 dw_body.append(' return 0;')
2182 dw_body.append('#elif defined(WIN32)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2183 dw_body.append(' // Register Window class')
2184 dw_body.append(' WNDCLASSEX wcex = {};')
2185 dw_body.append(' wcex.cbSize = sizeof( WNDCLASSEX);')
2186 dw_body.append(' wcex.style = CS_HREDRAW | CS_VREDRAW;')
2187 dw_body.append(' wcex.lpfnWndProc = WindowProcXgl;')
2188 dw_body.append(' wcex.cbClsExtra = 0;')
2189 dw_body.append(' wcex.cbWndExtra = 0;')
2190 dw_body.append(' wcex.hInstance = GetModuleHandle(0);')
2191 dw_body.append(' wcex.hIcon = LoadIcon(wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')
2192 dw_body.append(' wcex.hCursor = LoadCursor( NULL, IDC_ARROW);')
2193 dw_body.append(' wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1);')
2194 dw_body.append(' wcex.lpszMenuName = NULL;')
2195 dw_body.append(' wcex.lpszClassName = APP_NAME;')
2196 dw_body.append(' wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')
2197 dw_body.append(' if( !RegisterClassEx( &wcex))')
2198 dw_body.append(' {')
2199 dw_body.append(' glv_LogError("Failed to register windows class\\n");')
2200 dw_body.append(' return -1;')
2201 dw_body.append(' }\n')
2202 dw_body.append(' // create the window')
2203 dw_body.append(' m_windowHandle = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, 0, 0,')
2204 dw_body.append(' width, height, NULL, NULL, wcex.hInstance, NULL);\n')
2205 dw_body.append(' if (m_windowHandle)')
2206 dw_body.append(' {')
2207 dw_body.append(' ShowWindow( m_windowHandle, SW_SHOWDEFAULT);')
2208 dw_body.append(' m_windowWidth = width;')
2209 dw_body.append(' m_windowHeight = height;')
2210 dw_body.append(' } else {')
2211 dw_body.append(' glv_LogError("Failed to create window\\n");')
2212 dw_body.append(' return -1;')
2213 dw_body.append(' }')
2214 dw_body.append(' return 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2215 dw_body.append('#endif')
2216 dw_body.append('}\n')
2217 dw_body.append('void xglDisplay::resize_window(const unsigned int width, const unsigned int height)')
2218 dw_body.append('{')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2219 dw_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2220 dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')
2221 dw_body.append(' {')
2222 dw_body.append(' uint32_t values[2];')
2223 dw_body.append(' values[0] = width;')
2224 dw_body.append(' values[1] = height;')
2225 dw_body.append(' xcb_configure_window(m_WsiConnection.pConnection, m_XcbWindow, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);')
2226 dw_body.append(' m_windowWidth = width;')
2227 dw_body.append(' m_windowHeight = height;')
2228 dw_body.append(' }')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2229 dw_body.append('#elif defined(WIN32)')
2230 dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')
2231 dw_body.append(' {')
2232 dw_body.append(' SetWindowPos(get_window_handle(), HWND_TOP, 0, 0, width, height, SWP_NOMOVE);')
2233 dw_body.append(' m_windowWidth = width;')
2234 dw_body.append(' m_windowHeight = height;')
2235 dw_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2236 dw_body.append('#endif')
2237 dw_body.append('}\n')
2238 dw_body.append('void xglDisplay::process_event()')
2239 dw_body.append('{')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]2240 dw_body.append('}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2241 return "\n".join(dw_body)
2242
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]2243 def _generate_replay_objMemory_funcs(self):
2244 rof_body = []
2245 rof_body.append('void objMemory::setCount(const uint32_t num)')
2246 rof_body.append('{')
2247 rof_body.append(' m_numAllocations = num;')
2248 rof_body.append('}\n')
2249 rof_body.append('void objMemory::setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num)')
2250 rof_body.append('{')
2251 rof_body.append(' if (m_numAllocations != num && m_numAllocations != 0)')
2252 rof_body.append(' glv_LogError("objMemory::setReqs, internal mismatch on number of allocations");')
2253 rof_body.append(' if (m_pMemReqs == NULL && pReqs != NULL)')
2254 rof_body.append(' {')
2255 rof_body.append(' m_pMemReqs = (XGL_MEMORY_REQUIREMENTS *) glv_malloc(num * sizeof(XGL_MEMORY_REQUIREMENTS));')
2256 rof_body.append(' if (m_pMemReqs == NULL)')
2257 rof_body.append(' {')
2258 rof_body.append(' glv_LogError("objMemory::setReqs out of memory");')
2259 rof_body.append(' return;')
2260 rof_body.append(' }')
2261 rof_body.append(' memcpy(m_pMemReqs, pReqs, num);')
2262 rof_body.append(' }')
2263 rof_body.append('}\n')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]2264 # Custom code for memory mapping functions for app writes into mapped memory
2265 rof_body.append(' // memory mapping functions for app writes into mapped memory')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]2266 rof_body.append(' bool gpuMemory::isPendingAlloc()')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]2267 rof_body.append(' {')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]2268 rof_body.append(' return m_pendingAlloc;')
2269 rof_body.append(' }\n')
2270 rof_body.append(' void gpuMemory::setAllocInfo(const XGL_MEMORY_ALLOC_INFO *info, const bool pending)')
2271 rof_body.append(' {')
2272 rof_body.append(' m_pendingAlloc = pending;')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]2273 rof_body.append(' m_allocInfo = *info;')
2274 rof_body.append(' }\n')
2275 rof_body.append(' void gpuMemory::setMemoryDataAddr(void *pBuf)')
2276 rof_body.append(' {')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]2277 rof_body.append(' if (m_mapRange.empty())')
2278 rof_body.append(' {')
2279 rof_body.append(' glv_LogError("gpuMemory::setMemoryDataAddr() m_mapRange is empty\\n");')
2280 rof_body.append(' return;')
2281 rof_body.append(' }')
2282 rof_body.append(' struct mapRange mr = m_mapRange.back();')
2283 rof_body.append(' if (mr.pData != NULL)')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]2284 rof_body.append(' glv_LogWarn("gpuMemory::setMemoryDataAddr() data already mapped overwrite old mapping\\n");')
2285 rof_body.append(' else if (pBuf == NULL)')
2286 rof_body.append(' glv_LogWarn("gpuMemory::setMemoryDataAddr() adding NULL pointer\\n");')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]2287 rof_body.append(' mr.pData = pBuf;')
2288 rof_body.append(' }\n')
2289 rof_body.append(' void gpuMemory::setMemoryMapRange(void *pBuf, const size_t size, const size_t offset, const bool pending)')
2290 rof_body.append(' {')
2291 rof_body.append(' struct mapRange mr;')
2292 rof_body.append(' mr.pData = pBuf;')
2293 rof_body.append(' mr.size = size;')
2294 rof_body.append(' mr.offset = offset;')
2295 rof_body.append(' mr.pending = pending;')
2296 rof_body.append(' m_mapRange.push_back(mr);')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]2297 rof_body.append(' }\n')
2298 rof_body.append(' void gpuMemory::copyMappingData(const void* pSrcData)')
2299 rof_body.append(' {')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]2300 rof_body.append(' if (m_mapRange.empty())')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]2301 rof_body.append(' {')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]2302 rof_body.append(' glv_LogError("gpuMemory::copyMappingData() m_mapRange is empty\\n");')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]2303 rof_body.append(' return;')
2304 rof_body.append(' }')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]2305 rof_body.append(' struct mapRange mr = m_mapRange.back();')
2306 rof_body.append(' if (!pSrcData || !mr.pData)')
2307 rof_body.append(' {')
2308 rof_body.append(' if (!pSrcData)')
2309 rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null src pointer\\n");')
2310 rof_body.append(' else')
2311 rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null dest pointer size=%u\\n", m_allocInfo.allocationSize);')
2312 rof_body.append(' m_mapRange.pop_back();')
2313 rof_body.append(' return;')
2314 rof_body.append(' }')
2315 rof_body.append(' memcpy(mr.pData, pSrcData, m_allocInfo.allocationSize);')
2316 rof_body.append(' if (!mr.pending)')
2317 rof_body.append(' m_mapRange.pop_back();')
2318 rof_body.append(' }\n')
2319 rof_body.append(' size_t gpuMemory::getMemoryMapSize()')
2320 rof_body.append(' {')
2321 rof_body.append(' return (!m_mapRange.empty()) ? m_mapRange.back().size : 0;')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]2322 rof_body.append(' }\n')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]2323 return "\n".join(rof_body)
2324
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2325 def _generate_replay_structors(self):
2326 rs_body = []
Ian Elliott91e681e2015-02-18 15:35:00 -0700[diff] [blame]2327 rs_body.append('xglReplay::xglReplay(glvreplay_settings *pReplaySettings)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2328 rs_body.append('{')
Ian Elliott91e681e2015-02-18 15:35:00 -0700[diff] [blame]2329 rs_body.append(' g_pReplaySettings = pReplaySettings;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2330 rs_body.append(' m_display = new xglDisplay();')
Peter Lohrmannee751032015-02-26 10:51:36 -0800[diff] [blame]2331 rs_body.append(' m_pDSDump = NULL;')
Peter Lohrmann53e89242015-02-27 15:35:15 -0800[diff] [blame]2332 rs_body.append(' m_pCBDump = NULL;')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]2333 rs_body.append(' m_adjustForGPU = false;')
Jon Ashburn215a9662015-02-05 13:42:38 -0700[diff] [blame]2334 rs_body.append(' if (g_pReplaySettings && g_pReplaySettings->screenshotList) {')
2335 rs_body.append(' process_screenshot_list(g_pReplaySettings->screenshotList);')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]2336 rs_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2337 rs_body.append('}\n')
2338 rs_body.append('xglReplay::~xglReplay()')
2339 rs_body.append('{')
2340 rs_body.append(' delete m_display;')
2341 rs_body.append(' glv_platform_close_library(m_xglFuncs.m_libHandle);')
2342 rs_body.append('}')
2343 return "\n".join(rs_body)
2344
2345 def _generate_replay_init(self):
2346 ri_body = []
2347 ri_body.append('int xglReplay::init(glv_replay::Display & disp)')
2348 ri_body.append('{')
2349 ri_body.append(' int err;')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2350 ri_body.append('#if defined PLATFORM_LINUX')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2351 ri_body.append(' void * handle = dlopen("libXGL.so", RTLD_LAZY);')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2352 ri_body.append('#else')
2353 ri_body.append(' HMODULE handle = LoadLibrary("xgl.dll" );')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2354 ri_body.append('#endif\n')
2355 ri_body.append(' if (handle == NULL) {')
2356 ri_body.append(' glv_LogError("Failed to open xgl library.\\n");')
2357 ri_body.append(' return -1;')
2358 ri_body.append(' }')
2359 ri_body.append(' m_xglFuncs.init_funcs(handle);')
2360 ri_body.append(' disp.set_implementation(m_display);')
2361 ri_body.append(' if ((err = m_display->init(disp.get_gpu())) != 0) {')
2362 ri_body.append(' glv_LogError("Failed to init XGL display.\\n");')
2363 ri_body.append(' return err;')
2364 ri_body.append(' }')
2365 ri_body.append(' if (disp.get_window_handle() == 0)')
2366 ri_body.append(' {')
2367 ri_body.append(' if ((err = m_display->create_window(disp.get_width(), disp.get_height())) != 0) {')
2368 ri_body.append(' glv_LogError("Failed to create Window\\n");')
2369 ri_body.append(' return err;')
2370 ri_body.append(' }')
2371 ri_body.append(' }')
2372 ri_body.append(' else')
2373 ri_body.append(' {')
2374 ri_body.append(' if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)')
2375 ri_body.append(' {')
2376 ri_body.append(' glv_LogError("Failed to set Window\\n");')
2377 ri_body.append(' return err;')
2378 ri_body.append(' }')
2379 ri_body.append(' }')
2380 ri_body.append(' return 0;')
2381 ri_body.append('}')
2382 return "\n".join(ri_body)
2383
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2384 def _generate_replay_errors(self):
2385 re_body = []
2386 re_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn)')
2387 re_body.append('{')
2388 re_body.append(' glv_replay::GLV_REPLAY_RESULT res = resIn;')
2389 re_body.append(' if (resCall != resTrace) {')
2390 re_body.append(' glv_LogWarn("Mismatched return from API call (%s) traced result %s, replay result %s\\n", entrypointName,')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2391 re_body.append(' string_XGL_RESULT((XGL_RESULT)resTrace), string_XGL_RESULT((XGL_RESULT)resCall));')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2392 re_body.append(' res = glv_replay::GLV_REPLAY_BAD_RETURN;')
2393 re_body.append(' }')
2394 re_body.append('#if 0')
2395 re_body.append(' if (resCall != XGL_SUCCESS) {')
2396 re_body.append(' glv_LogWarn("API call (%s) returned failed result %s\\n", entrypointName, string_XGL_RESULT(resCall));')
2397 re_body.append(' }')
2398 re_body.append('#endif')
2399 re_body.append(' return res;')
2400 re_body.append('}')
2401 return "\n".join(re_body)
2402
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2403 def _generate_replay_validation_funcs(self):
2404 rvf_body = []
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2405 rvf_body.append('void xglReplay::push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char * pMsg)')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2406 rvf_body.append('{')
2407 rvf_body.append(' struct validationMsg msgObj;')
2408 rvf_body.append(' msgObj.validationLevel = validationLevel;')
2409 rvf_body.append(' msgObj.srcObject = srcObject;')
2410 rvf_body.append(' msgObj.location = location;')
2411 rvf_body.append(' msgObj.msgCode = msgCode;')
2412 rvf_body.append(' strncpy(msgObj.msg, pMsg, 256);')
2413 rvf_body.append(" msgObj.msg[255] = '\\0';")
2414 rvf_body.append(' m_validationMsgs.push_back(msgObj);')
2415 rvf_body.append('}\n')
2416 rvf_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::pop_validation_msgs()')
2417 rvf_body.append('{')
2418 rvf_body.append(' if (m_validationMsgs.size() == 0)')
2419 rvf_body.append(' return glv_replay::GLV_REPLAY_SUCCESS;')
2420 rvf_body.append(' m_validationMsgs.clear();')
2421 rvf_body.append(' return glv_replay::GLV_REPLAY_VALIDATION_ERROR;')
2422 rvf_body.append('}')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]2423 rvf_body.append('int xglReplay::dump_validation_data()')
2424 rvf_body.append('{')
Jeremy Hayes7ec63022015-02-26 15:59:19 -0700[diff] [blame]2425 rvf_body.append(' if (!m_pDSDump || !m_pCBDump)')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]2426 rvf_body.append(' {')
Jeremy Hayes7ec63022015-02-26 15:59:19 -0700[diff] [blame]2427 rvf_body.append(' return -1;')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]2428 rvf_body.append(' }')
Jeremy Hayes7ec63022015-02-26 15:59:19 -0700[diff] [blame]2429 rvf_body.append(' m_pDSDump((char *) "pipeline_dump.dot");')
2430 rvf_body.append(' m_pCBDump((char *) "cb_dump.dot");')
2431 rvf_body.append(' return 0;')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]2432 rvf_body.append('}')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2433 return "\n".join(rvf_body)
2434
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2435 def _generate_replay_init_funcs(self):
2436 rif_body = []
2437 rif_body.append('void xglFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')
2438 for proto in self.protos:
2439 rif_body.append(' real_xgl%s = (type_xgl%s)(glv_platform_get_library_entrypoint(handle, "xgl%s"));' % (proto.name, proto.name, proto.name))
2440 rif_body.append('}')
2441 return "\n".join(rif_body)
2442
2443 def _get_packet_param(self, t, n):
2444 # list of types that require remapping
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2445 remap_list = xgl.object_type_list
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2446 param_exclude_list = ['p1', 'p2', 'pGpus', 'pDescriptorSets']
2447 if t.strip('*').replace('const ', '') in remap_list and n not in param_exclude_list:
2448 if '*' in t:
2449 if 'const ' not in t:
2450 return 'remap(*pPacket->%s)' % (n)
2451 else: # TODO : Don't remap array ptrs?
2452 return 'pPacket->%s' % (n)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2453 return 'remap(pPacket->%s)' % (n)
2454 return 'pPacket->%s' % (n)
2455
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]2456 def _gen_replay_enum_gpus(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2457 ieg_body = []
2458 ieg_body.append(' if (!m_display->m_initedXGL)')
2459 ieg_body.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2460 ieg_body.append(' uint32_t gpuCount;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2461 ieg_body.append(' XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2462 ieg_body.append(' uint32_t maxGpus = (pPacket->maxGpus < XGL_MAX_PHYSICAL_GPUS) ? pPacket->maxGpus : XGL_MAX_PHYSICAL_GPUS;')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]2463 ieg_body.append(' replayResult = m_xglFuncs.real_xglEnumerateGpus(remap(pPacket->instance), maxGpus, &gpuCount, &gpus[0]);')
2464 ieg_body.append(' CHECK_RETURN_VALUE(xglEnumerateGpus);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2465 ieg_body.append(' //TODO handle different number of gpus in trace versus replay')
2466 ieg_body.append(' if (gpuCount != *(pPacket->pGpuCount))')
2467 ieg_body.append(' {')
2468 ieg_body.append(' glv_LogWarn("number of gpus mismatched in replay %u versus trace %u\\n", gpuCount, *(pPacket->pGpuCount));')
2469 ieg_body.append(' }')
2470 ieg_body.append(' else if (gpuCount == 0)')
2471 ieg_body.append(' {')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]2472 ieg_body.append(' glv_LogError("xglEnumerateGpus number of gpus is zero\\n");')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2473 ieg_body.append(' }')
2474 ieg_body.append(' else')
2475 ieg_body.append(' {')
2476 ieg_body.append(' glv_LogInfo("Enumerated %d GPUs in the system\\n", gpuCount);')
2477 ieg_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2478 ieg_body.append(' // TODO handle enumeration results in a different order from trace to replay')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2479 ieg_body.append(' for (uint32_t i = 0; i < gpuCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2480 ieg_body.append(' {')
2481 ieg_body.append(' if (pPacket->pGpus)')
2482 ieg_body.append(' add_to_map(&(pPacket->pGpus[i]), &(gpus[i]));')
2483 ieg_body.append(' }')
2484 ieg_body.append(' }')
2485 return "\n".join(ieg_body)
2486
2487 def _gen_replay_get_gpu_info(self):
2488 ggi_body = []
2489 ggi_body.append(' if (!m_display->m_initedXGL)')
2490 ggi_body.append(' {')
2491 ggi_body.append(' switch (pPacket->infoType) {')
2492 ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:')
2493 ggi_body.append(' {')
2494 ggi_body.append(' XGL_PHYSICAL_GPU_PROPERTIES gpuProps;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2495 ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2496 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
2497 ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuProps);')
2498 ggi_body.append(' if (pPacket->pData != NULL)')
2499 ggi_body.append(' {')
2500 ggi_body.append(' glv_LogInfo("Replay Gpu Properties\\n");')
2501 ggi_body.append(' glv_LogInfo("Vendor ID %x, Device ID %x, name %s\\n",gpuProps.vendorId, gpuProps.deviceId, gpuProps.gpuName);')
2502 ggi_body.append(' glv_LogInfo("API version %u, Driver version %u, gpu Type %u\\n",gpuProps.apiVersion, gpuProps.driverVersion, gpuProps.gpuType);')
2503 ggi_body.append(' }')
2504 ggi_body.append(' break;')
2505 ggi_body.append(' }')
2506 ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:')
2507 ggi_body.append(' {')
2508 ggi_body.append(' XGL_PHYSICAL_GPU_PERFORMANCE gpuPerfs;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2509 ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2510 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
2511 ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuPerfs);')
2512 ggi_body.append(' if (pPacket->pData != NULL)')
2513 ggi_body.append(' {')
2514 ggi_body.append(' glv_LogInfo("Replay Gpu Performance\\n");')
2515 ggi_body.append(' glv_LogInfo("Max GPU clock %f, max shader ALUs/clock %f, max texel fetches/clock %f\\n",gpuPerfs.maxGpuClock, gpuPerfs.aluPerClock, gpuPerfs.texPerClock);')
2516 ggi_body.append(' glv_LogInfo("Max primitives/clock %f, Max pixels/clock %f\\n",gpuPerfs.primsPerClock, gpuPerfs.pixelsPerClock);')
2517 ggi_body.append(' }')
2518 ggi_body.append(' break;')
2519 ggi_body.append(' }')
2520 ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:')
2521 ggi_body.append(' {')
2522 ggi_body.append(' XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *pGpuQueue, *pQ;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2523 ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);')
2524 ggi_body.append(' size_t numQueues = 1;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2525 ggi_body.append(' assert(pPacket->pDataSize);')
2526 ggi_body.append(' if ((*(pPacket->pDataSize) % dataSize) != 0)')
2527 ggi_body.append(' glv_LogWarn("xglGetGpuInfo() for GPU_QUEUE_PROPERTIES not an integral data size assuming 1\\n");')
2528 ggi_body.append(' else')
2529 ggi_body.append(' numQueues = *(pPacket->pDataSize) / dataSize;')
2530 ggi_body.append(' dataSize = numQueues * dataSize;')
2531 ggi_body.append(' pQ = static_cast < XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *> (glv_malloc(dataSize));')
2532 ggi_body.append(' pGpuQueue = pQ;')
2533 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
2534 ggi_body.append(' (pPacket->pData == NULL) ? NULL : pGpuQueue);')
2535 ggi_body.append(' if (pPacket->pData != NULL)')
2536 ggi_body.append(' {')
2537 ggi_body.append(' for (unsigned int i = 0; i < numQueues; i++)')
2538 ggi_body.append(' {')
2539 ggi_body.append(' glv_LogInfo("Replay Gpu Queue Property for index %d, flags %u\\n", i, pGpuQueue->queueFlags);')
2540 ggi_body.append(' glv_LogInfo("Max available count %u, max atomic counters %u, supports timestamps %u\\n",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);')
2541 ggi_body.append(' pGpuQueue++;')
2542 ggi_body.append(' }')
2543 ggi_body.append(' }')
2544 ggi_body.append(' glv_free(pQ);')
2545 ggi_body.append(' break;')
2546 ggi_body.append(' }')
2547 ggi_body.append(' default:')
2548 ggi_body.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2549 ggi_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2550 ggi_body.append(' void* pData = NULL;')
2551 ggi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2552 ggi_body.append(' {')
2553 ggi_body.append(' size = *pPacket->pDataSize;')
2554 ggi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2555 ggi_body.append(' }')
2556 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &size, pData);')
2557 ggi_body.append(' if (replayResult == XGL_SUCCESS)')
2558 ggi_body.append(' {')
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]2559 ggi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2560 ggi_body.append(' {')
2561 ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2562 ggi_body.append(' }')
2563 ggi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2564 ggi_body.append(' {')
2565 ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned differing data contents than the trace file contained.\\n");')
2566 ggi_body.append(' }')
2567 ggi_body.append(' }')
2568 ggi_body.append(' glv_free(pData);')
2569 ggi_body.append(' break;')
2570 ggi_body.append(' }')
2571 ggi_body.append(' };')
2572 ggi_body.append(' CHECK_RETURN_VALUE(xglGetGpuInfo);')
2573 ggi_body.append(' }')
2574 return "\n".join(ggi_body)
2575
2576 def _gen_replay_create_device(self):
2577 cd_body = []
2578 cd_body.append(' if (!m_display->m_initedXGL)')
2579 cd_body.append(' {')
2580 cd_body.append(' XGL_DEVICE device;')
Peter Lohrmannbe24ff02015-01-08 19:47:03 -0800[diff] [blame]2581 cd_body.append(' if (g_xglReplaySettings.debugLevel > 0)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2582 cd_body.append(' {')
Jon Ashburn6cad43c2014-12-19 12:31:19 -0700[diff] [blame]2583 cd_body.append(' XGL_DEVICE_CREATE_INFO cInfo, *ci, *pCreateInfoSaved;')
Peter Lohrmannd4451052015-01-09 12:34:50 -0800[diff] [blame]2584 cd_body.append(' unsigned int numLayers = 0;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2585 cd_body.append(' char ** layersStr = get_enableLayers_list(&numLayers);')
Jon Ashburne8025e92015-01-13 17:24:49 -0700[diff] [blame]2586 cd_body.append(' apply_layerSettings_overrides();')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2587 cd_body.append(' XGL_LAYER_CREATE_INFO layerInfo;')
Jon Ashburn6cad43c2014-12-19 12:31:19 -0700[diff] [blame]2588 cd_body.append(' pCreateInfoSaved = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2589 cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')
Peter Lohrmannd4451052015-01-09 12:34:50 -0800[diff] [blame]2590
2591 cd_body.append(' if (layersStr != NULL && numLayers > 0)')
2592 cd_body.append(' {')
2593 cd_body.append(' while (ci->pNext != NULL)')
2594 cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) ci->pNext;')
2595 cd_body.append(' ci->pNext = &layerInfo;')
2596 cd_body.append(' layerInfo.sType = XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO;')
2597 cd_body.append(' layerInfo.pNext = 0;')
2598 cd_body.append(' layerInfo.layerCount = numLayers;')
2599 cd_body.append(' layerInfo.ppActiveLayerNames = layersStr;')
2600 cd_body.append(' }')
2601
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2602 cd_body.append(' memcpy(&cInfo, pPacket->pCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO));')
2603 cd_body.append(' cInfo.flags = pPacket->pCreateInfo->flags | XGL_DEVICE_CREATE_VALIDATION_BIT;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2604 cd_body.append(' cInfo.maxValidationLevel = (XGL_VALIDATION_LEVEL)((g_xglReplaySettings.debugLevel <= 4) ? (unsigned int) XGL_VALIDATION_LEVEL_0 + g_xglReplaySettings.debugLevel : (unsigned int) XGL_VALIDATION_LEVEL_0);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2605 cd_body.append(' pPacket->pCreateInfo = &cInfo;')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2606 cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')
Jon Ashburn6cad43c2014-12-19 12:31:19 -0700[diff] [blame]2607 cd_body.append(' // restore the packet for next replay')
2608 cd_body.append(' ci->pNext = NULL;')
2609 cd_body.append(' pPacket->pCreateInfo = pCreateInfoSaved;')
Peter Lohrmannd4451052015-01-09 12:34:50 -0800[diff] [blame]2610 cd_body.append(' release_enableLayer_list(layersStr);')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2611 cd_body.append(' if (xglDbgRegisterMsgCallback(g_fpDbgMsgCallback, NULL) != XGL_SUCCESS)')
2612 cd_body.append(' glv_LogError("Failed to register xgl callback for replayer error handling\\n");')
Ian Elliott9080f852015-03-03 09:50:57 -0700[diff] [blame]2613 cd_body.append('#if !defined(_WIN32)')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]2614 cd_body.append(' m_pDSDump = (DRAW_STATE_DUMP_DOT_FILE) m_xglFuncs.real_xglGetProcAddr(remap(pPacket->gpu), "drawStateDumpDotFile");')
Jeremy Hayes7ec63022015-02-26 15:59:19 -0700[diff] [blame]2615 cd_body.append(' m_pCBDump = (DRAW_STATE_DUMP_COMMAND_BUFFER_DOT_FILE) m_xglFuncs.real_xglGetProcAddr(remap(pPacket->gpu), "drawStateDumpCommandBufferDotFile");')
Ian Elliott9080f852015-03-03 09:50:57 -0700[diff] [blame]2616 cd_body.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2617 cd_body.append(' }')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2618 cd_body.append(' else ')
2619 cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2620 cd_body.append(' CHECK_RETURN_VALUE(xglCreateDevice);')
2621 cd_body.append(' if (replayResult == XGL_SUCCESS)')
2622 cd_body.append(' {')
2623 cd_body.append(' add_to_map(pPacket->pDevice, &device);')
2624 cd_body.append(' }')
2625 cd_body.append(' }')
2626 return "\n".join(cd_body)
2627
2628 def _gen_replay_get_extension_support(self):
2629 ges_body = []
2630 ges_body.append(' if (!m_display->m_initedXGL) {')
2631 ges_body.append(' replayResult = m_xglFuncs.real_xglGetExtensionSupport(remap(pPacket->gpu), pPacket->pExtName);')
2632 ges_body.append(' CHECK_RETURN_VALUE(xglGetExtensionSupport);')
2633 ges_body.append(' if (replayResult == XGL_SUCCESS) {')
2634 ges_body.append(' for (unsigned int ext = 0; ext < sizeof(g_extensions) / sizeof(g_extensions[0]); ext++)')
2635 ges_body.append(' {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]2636 ges_body.append(' if (!strncmp(g_extensions[ext], pPacket->pExtName, strlen(g_extensions[ext]))) {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2637 ges_body.append(' bool extInList = false;')
2638 ges_body.append(' for (unsigned int j = 0; j < m_display->m_extensions.size(); ++j) {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]2639 ges_body.append(' if (!strncmp(m_display->m_extensions[j], g_extensions[ext], strlen(g_extensions[ext])))')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2640 ges_body.append(' extInList = true;')
2641 ges_body.append(' break;')
2642 ges_body.append(' }')
2643 ges_body.append(' if (!extInList)')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2644 ges_body.append(' m_display->m_extensions.push_back((char *) g_extensions[ext]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2645 ges_body.append(' break;')
2646 ges_body.append(' }')
2647 ges_body.append(' }')
2648 ges_body.append(' }')
2649 ges_body.append(' }')
2650 return "\n".join(ges_body)
2651
2652 def _gen_replay_queue_submit(self):
2653 qs_body = []
2654 qs_body.append(' XGL_CMD_BUFFER *remappedBuffers = NULL;')
2655 qs_body.append(' if (pPacket->pCmdBuffers != NULL)')
2656 qs_body.append(' {')
2657 qs_body.append(' remappedBuffers = GLV_NEW_ARRAY( XGL_CMD_BUFFER, pPacket->cmdBufferCount);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2658 qs_body.append(' for (uint32_t i = 0; i < pPacket->cmdBufferCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2659 qs_body.append(' {')
2660 qs_body.append(' *(remappedBuffers + i) = remap(*(pPacket->pCmdBuffers + i));')
2661 qs_body.append(' }')
2662 qs_body.append(' }')
2663 qs_body.append(' XGL_MEMORY_REF* memRefs = NULL;')
2664 qs_body.append(' if (pPacket->pMemRefs != NULL)')
2665 qs_body.append(' {')
2666 qs_body.append(' memRefs = GLV_NEW_ARRAY(XGL_MEMORY_REF, pPacket->memRefCount);')
2667 qs_body.append(' memcpy(memRefs, pPacket->pMemRefs, sizeof(XGL_MEMORY_REF) * pPacket->memRefCount);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2668 qs_body.append(' for (uint32_t i = 0; i < pPacket->memRefCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2669 qs_body.append(' {')
2670 qs_body.append(' memRefs[i].mem = remap(pPacket->pMemRefs[i].mem);')
2671 qs_body.append(' }')
2672 qs_body.append(' }')
2673 qs_body.append(' replayResult = m_xglFuncs.real_xglQueueSubmit(remap(pPacket->queue), pPacket->cmdBufferCount, remappedBuffers, pPacket->memRefCount,')
2674 qs_body.append(' memRefs, remap(pPacket->fence));')
2675 qs_body.append(' GLV_DELETE(remappedBuffers);')
2676 qs_body.append(' GLV_DELETE(memRefs);')
2677 return "\n".join(qs_body)
2678
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2679 def _gen_replay_get_object_info(self):
2680 goi_body = []
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2681 goi_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2682 goi_body.append(' void* pData = NULL;')
2683 goi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2684 goi_body.append(' {')
2685 goi_body.append(' size = *pPacket->pDataSize;')
2686 goi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2687 goi_body.append(' memcpy(pData, pPacket->pData, *pPacket->pDataSize);')
2688 goi_body.append(' }')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]2689 goi_body.append(' // TODO only search for object once rather than at remap() and init_objMemXXX()')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2690 goi_body.append(' replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);')
2691 goi_body.append(' if (replayResult == XGL_SUCCESS)')
2692 goi_body.append(' {')
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]2693 goi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2694 goi_body.append(' {')
2695 goi_body.append(' glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]2696 goi_body.append(' } else if (pData != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2697 goi_body.append(' {')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]2698 goi_body.append(' switch (pPacket->infoType)')
2699 goi_body.append(' {')
2700 goi_body.append(' case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:')
2701 goi_body.append(' {')
2702 goi_body.append(' uint32_t traceCount = *((uint32_t *) pPacket->pData);')
2703 goi_body.append(' uint32_t replayCount = *((uint32_t *) pData);')
2704 goi_body.append(' if (traceCount != replayCount)')
2705 goi_body.append(' glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_ALLOCATION_COUNT) mismatch: trace count %u, replay count %u\\n", traceCount, replayCount);')
2706 goi_body.append(' if (m_adjustForGPU)')
2707 goi_body.append(' init_objMemCount(pPacket->object, replayCount);')
2708 goi_body.append(' break;')
2709 goi_body.append(' }')
2710 goi_body.append(' case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:')
2711 goi_body.append(' {')
2712 goi_body.append(' XGL_MEMORY_REQUIREMENTS *traceReqs = (XGL_MEMORY_REQUIREMENTS *) pPacket->pData;')
2713 goi_body.append(' XGL_MEMORY_REQUIREMENTS *replayReqs = (XGL_MEMORY_REQUIREMENTS *) pData;')
2714 goi_body.append(' unsigned int num = size / sizeof(XGL_MEMORY_REQUIREMENTS);')
2715 goi_body.append(' for (unsigned int i = 0; i < num; i++)')
2716 goi_body.append(' {')
2717 goi_body.append(' if (traceReqs->size != replayReqs->size)')
2718 goi_body.append(' glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace size %u, replay size %u\\n", traceReqs->size, replayReqs->size);')
2719 goi_body.append(' if (traceReqs->alignment != replayReqs->alignment)')
2720 goi_body.append(' glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace alignment %u, replay aligmnent %u\\n", traceReqs->alignment, replayReqs->alignment);')
2721 goi_body.append(' if (traceReqs->granularity != replayReqs->granularity)')
2722 goi_body.append(' glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace granularity %u, replay granularity %u\\n", traceReqs->granularity, replayReqs->granularity);')
2723 goi_body.append(' if (traceReqs->memProps != replayReqs->memProps)')
2724 goi_body.append(' glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memProps %u, replay memProps %u\\n", traceReqs->memProps, replayReqs->memProps);')
2725 goi_body.append(' if (traceReqs->memType != replayReqs->memType)')
2726 goi_body.append(' glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memType %u, replay memType %u\\n", traceReqs->memType, replayReqs->memType);')
2727 goi_body.append(' traceReqs++;')
2728 goi_body.append(' replayReqs++;')
2729 goi_body.append(' }')
2730 goi_body.append(' if (m_adjustForGPU)')
2731 goi_body.append(' init_objMemReqs(pPacket->object, replayReqs - num, num);')
2732 goi_body.append(' break;')
2733 goi_body.append(' }')
2734 goi_body.append(' default:')
2735 goi_body.append(' if (memcmp(pData, pPacket->pData, size) != 0)')
2736 goi_body.append(' glv_LogWarn("xglGetObjectInfo() mismatch on *pData: between trace and replay *pDataSize %u\\n", size);')
2737 goi_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2738 goi_body.append(' }')
2739 goi_body.append(' }')
2740 goi_body.append(' glv_free(pData);')
2741 return "\n".join(goi_body)
2742
2743 def _gen_replay_get_format_info(self):
2744 gfi_body = []
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2745 gfi_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2746 gfi_body.append(' void* pData = NULL;')
2747 gfi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2748 gfi_body.append(' {')
2749 gfi_body.append(' size = *pPacket->pDataSize;')
2750 gfi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2751 gfi_body.append(' }')
2752 gfi_body.append(' replayResult = m_xglFuncs.real_xglGetFormatInfo(remap(pPacket->device), pPacket->format, pPacket->infoType, &size, pData);')
2753 gfi_body.append(' if (replayResult == XGL_SUCCESS)')
2754 gfi_body.append(' {')
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]2755 gfi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2756 gfi_body.append(' {')
2757 gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2758 gfi_body.append(' }')
2759 gfi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2760 gfi_body.append(' {')
2761 gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned differing data contents than the trace file contained.\\n");')
2762 gfi_body.append(' }')
2763 gfi_body.append(' }')
2764 gfi_body.append(' glv_free(pData);')
2765 return "\n".join(gfi_body)
2766
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]2767 def _gen_replay_create_image(self):
2768 ci_body = []
2769 ci_body.append(' struct imageObj local_imageObj;')
2770 ci_body.append(' replayResult = m_xglFuncs.real_xglCreateImage(remap(pPacket->device), pPacket->pCreateInfo, &local_imageObj.replayImage);')
2771 ci_body.append(' if (replayResult == XGL_SUCCESS)')
2772 ci_body.append(' {')
2773 ci_body.append(' add_to_map(pPacket->pImage, &local_imageObj);')
2774 ci_body.append(' }')
2775 return "\n".join(ci_body)
2776
2777 def _gen_replay_create_buffer(self):
2778 cb_body = []
2779 cb_body.append(' struct bufferObj local_bufferObj;')
2780 cb_body.append(' replayResult = m_xglFuncs.real_xglCreateBuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_bufferObj.replayBuffer);')
2781 cb_body.append(' if (replayResult == XGL_SUCCESS)')
2782 cb_body.append(' {')
2783 cb_body.append(' add_to_map(pPacket->pBuffer, &local_bufferObj);')
2784 cb_body.append(' }')
2785 return "\n".join(cb_body)
2786
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2787 def _gen_replay_get_image_subresource_info(self):
2788 isi_body = []
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2789 isi_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2790 isi_body.append(' void* pData = NULL;')
2791 isi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2792 isi_body.append(' {')
2793 isi_body.append(' size = *pPacket->pDataSize;')
2794 isi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2795 isi_body.append(' }')
2796 isi_body.append(' replayResult = m_xglFuncs.real_xglGetImageSubresourceInfo(remap(pPacket->image), pPacket->pSubresource, pPacket->infoType, &size, pData);')
2797 isi_body.append(' if (replayResult == XGL_SUCCESS)')
2798 isi_body.append(' {')
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]2799 isi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2800 isi_body.append(' {')
2801 isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2802 isi_body.append(' }')
2803 isi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2804 isi_body.append(' {')
2805 isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned differing data contents than the trace file contained.\\n");')
2806 isi_body.append(' }')
2807 isi_body.append(' }')
2808 isi_body.append(' glv_free(pData);')
2809 return "\n".join(isi_body)
2810
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2811 def _gen_replay_update_descriptors(self):
2812 ud_body = []
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2813 # We have to remap handles internal to the structures so save the handles prior to remap and then restore
2814 # Rather than doing a deep memcpy of the entire struct and fixing any intermediate pointers, do save and restores via STL queue
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2815 ud_body.append(' XGL_UPDATE_SAMPLERS* pUpdateChain = (XGL_UPDATE_SAMPLERS*)pPacket->pUpdateChain;')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2816 ud_body.append(' std::queue<XGL_SAMPLER> saveSamplers;')
2817 ud_body.append(' std::queue<XGL_BUFFER_VIEW> saveBufferViews;')
2818 ud_body.append(' std::queue<XGL_IMAGE_VIEW> saveImageViews;')
2819 ud_body.append(' std::queue<XGL_DESCRIPTOR_SET> saveDescSets;')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2820 ud_body.append(' while (pUpdateChain) {')
2821 ud_body.append(' switch(pUpdateChain->sType)')
2822 ud_body.append(' {')
2823 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2824 ud_body.append(' for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLERS*)pUpdateChain)->count; i++) {')
2825 ud_body.append(' XGL_SAMPLER* pLocalSampler = (XGL_SAMPLER*) &((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i];')
2826 ud_body.append(' saveSamplers.push(*pLocalSampler);')
Tobin Ehlisca21de22015-02-04 14:57:24 -0700[diff] [blame]2827 ud_body.append(' *pLocalSampler = remap(((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i]);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2828 ud_body.append(' }')
2829 ud_body.append(' break;')
2830 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2831 ud_body.append(' {')
2832 ud_body.append(' XGL_UPDATE_SAMPLER_TEXTURES *pUST = (XGL_UPDATE_SAMPLER_TEXTURES *) pUpdateChain;')
2833 ud_body.append(' for (uint32_t i = 0; i < pUST->count; i++) {')
2834 ud_body.append(' XGL_SAMPLER *pLocalSampler = (XGL_SAMPLER *) &pUST->pSamplerImageViews[i].pSampler;')
2835 ud_body.append(' saveSamplers.push(*pLocalSampler);')
2836 ud_body.append(' *pLocalSampler = remap(pUST->pSamplerImageViews[i].pSampler);')
2837 ud_body.append(' XGL_IMAGE_VIEW *pLocalView = (XGL_IMAGE_VIEW *) &pUST->pSamplerImageViews[i].pImageView->view;')
2838 ud_body.append(' saveImageViews.push(*pLocalView);')
2839 ud_body.append(' *pLocalView = remap(pUST->pSamplerImageViews[i].pImageView->view);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2840 ud_body.append(' }')
2841 ud_body.append(' break;')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2842 ud_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2843 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2844 ud_body.append(' {')
2845 ud_body.append(' XGL_UPDATE_IMAGES *pUI = (XGL_UPDATE_IMAGES*) pUpdateChain;')
2846 ud_body.append(' for (uint32_t i = 0; i < pUI->count; i++) {')
2847 ud_body.append(' XGL_IMAGE_VIEW* pLocalView = (XGL_IMAGE_VIEW*) &pUI->pImageViews[i]->view;')
2848 ud_body.append(' saveImageViews.push(*pLocalView);')
2849 ud_body.append(' *pLocalView = remap(pUI->pImageViews[i]->view);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2850 ud_body.append(' }')
2851 ud_body.append(' break;')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2852 ud_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2853 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2854 ud_body.append(' {')
2855 ud_body.append(' XGL_UPDATE_BUFFERS *pUB = (XGL_UPDATE_BUFFERS *) pUpdateChain;')
2856 ud_body.append(' for (uint32_t i = 0; i < pUB->count; i++) {')
2857 ud_body.append(' XGL_BUFFER_VIEW* pLocalView = (XGL_BUFFER_VIEW*) &pUB->pBufferViews[i]->view;')
2858 ud_body.append(' saveBufferViews.push(*pLocalView);')
2859 ud_body.append(' *pLocalView = remap(pUB->pBufferViews[i]->view);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2860 ud_body.append(' }')
2861 ud_body.append(' break;')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2862 ud_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2863 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2864 ud_body.append(' saveDescSets.push(((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet);')
2865 ud_body.append(' ((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet = remap(((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2866 ud_body.append(' break;')
2867 ud_body.append(' default:')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2868 ud_body.append(' assert(0);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2869 ud_body.append(' break;')
2870 ud_body.append(' }')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2871 ud_body.append(' pUpdateChain = (XGL_UPDATE_SAMPLERS*) pUpdateChain->pNext;')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2872 ud_body.append(' }')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2873 ud_body.append(' m_xglFuncs.real_xglUpdateDescriptors(remap(pPacket->descriptorSet), pPacket->pUpdateChain);')
2874 ud_body.append(' pUpdateChain = (XGL_UPDATE_SAMPLERS*) pPacket->pUpdateChain;')
2875 ud_body.append(' while (pUpdateChain) {')
2876 ud_body.append(' switch(pUpdateChain->sType)')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2877 ud_body.append(' {')
2878 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2879 ud_body.append(' for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLERS*)pUpdateChain)->count; i++) {')
2880 ud_body.append(' XGL_SAMPLER* pLocalSampler = (XGL_SAMPLER*) &((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i];')
2881 ud_body.append(' *pLocalSampler = saveSamplers.front();')
2882 ud_body.append(' saveSamplers.pop();')
2883 ud_body.append(' }')
2884 ud_body.append(' break;')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2885 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2886 ud_body.append(' {')
2887 ud_body.append(' XGL_UPDATE_SAMPLER_TEXTURES *pUST = (XGL_UPDATE_SAMPLER_TEXTURES *) pUpdateChain;')
2888 ud_body.append(' for (uint32_t i = 0; i < pUST->count; i++) {')
2889 ud_body.append(' XGL_SAMPLER *plocalSampler = (XGL_SAMPLER *) &pUST->pSamplerImageViews[i].pSampler;')
2890 ud_body.append(' *plocalSampler = saveSamplers.front();')
2891 ud_body.append(' saveSamplers.pop();')
2892 ud_body.append(' XGL_IMAGE_VIEW *pLocalView = (XGL_IMAGE_VIEW *) &pUST->pSamplerImageViews[i].pImageView->view;')
2893 ud_body.append(' *pLocalView = saveImageViews.front();')
2894 ud_body.append(' saveImageViews.pop();')
2895 ud_body.append(' }')
2896 ud_body.append(' break;')
2897 ud_body.append(' }')
2898 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
2899 ud_body.append(' {')
2900 ud_body.append(' XGL_UPDATE_IMAGES *pUI = (XGL_UPDATE_IMAGES*) pUpdateChain;')
2901 ud_body.append(' for (uint32_t i = 0; i < pUI->count; i++) {')
2902 ud_body.append(' XGL_IMAGE_VIEW* pLocalView = (XGL_IMAGE_VIEW*) &pUI->pImageViews[i]->view;')
2903 ud_body.append(' *pLocalView = saveImageViews.front();')
2904 ud_body.append(' saveImageViews.pop();')
2905 ud_body.append(' }')
2906 ud_body.append(' break;')
2907 ud_body.append(' }')
2908 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
2909 ud_body.append(' {')
2910 ud_body.append(' XGL_UPDATE_BUFFERS *pUB = (XGL_UPDATE_BUFFERS *) pUpdateChain;')
2911 ud_body.append(' for (uint32_t i = 0; i < pUB->count; i++) {')
2912 ud_body.append(' XGL_BUFFER_VIEW* pLocalView = (XGL_BUFFER_VIEW*) &pUB->pBufferViews[i]->view;')
2913 ud_body.append(' *pLocalView = saveBufferViews.front();')
2914 ud_body.append(' saveBufferViews.pop();')
2915 ud_body.append(' }')
2916 ud_body.append(' break;')
2917 ud_body.append(' }')
2918 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
2919 ud_body.append(' ((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet = saveDescSets.front();')
2920 ud_body.append(' saveDescSets.pop();')
2921 ud_body.append(' //pFreeMe = (XGL_UPDATE_SAMPLERS*)pLocalUpdateChain;')
2922 ud_body.append(' //pLocalUpdateChain = (void*)((XGL_UPDATE_SAMPLERS*)pLocalUpdateChain)->pNext;')
2923 ud_body.append(' //free(pFreeMe);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2924 ud_body.append(' break;')
2925 ud_body.append(' default:')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2926 ud_body.append(' assert(0);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2927 ud_body.append(' break;')
2928 ud_body.append(' }')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2929 ud_body.append(' pUpdateChain = (XGL_UPDATE_SAMPLERS*) pUpdateChain->pNext;')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2930 ud_body.append(' }')
2931 return "\n".join(ud_body)
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2932
2933 def _gen_replay_create_descriptor_set_layout(self):
2934 cdsl_body = []
Jon Ashburnb92a2272015-02-10 14:32:23 -0700[diff] [blame]2935 cdsl_body.append(' XGL_SAMPLER saveSampler;')
2936 cdsl_body.append(' if (pPacket->pSetLayoutInfoList != NULL) {')
2937 cdsl_body.append(' XGL_SAMPLER *pSampler = (XGL_SAMPLER *) &pPacket->pSetLayoutInfoList->immutableSampler;')
2938 cdsl_body.append(' saveSampler = pPacket->pSetLayoutInfoList->immutableSampler;')
2939 cdsl_body.append(' *pSampler = remap(saveSampler);')
2940 cdsl_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2941 cdsl_body.append(' XGL_DESCRIPTOR_SET_LAYOUT setLayout;')
Jon Ashburnb92a2272015-02-10 14:32:23 -0700[diff] [blame]2942 cdsl_body.append(' replayResult = m_xglFuncs.real_xglCreateDescriptorSetLayout(remap(pPacket->device), pPacket->stageFlags, pPacket->pSetBindPoints, remap(pPacket->priorSetLayout), pPacket->pSetLayoutInfoList, &setLayout);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2943 cdsl_body.append(' if (replayResult == XGL_SUCCESS)')
2944 cdsl_body.append(' {')
2945 cdsl_body.append(' add_to_map(pPacket->pSetLayout, &setLayout);')
2946 cdsl_body.append(' }')
Jon Ashburnb92a2272015-02-10 14:32:23 -0700[diff] [blame]2947 cdsl_body.append(' if (pPacket->pSetLayoutInfoList != NULL) {')
2948 cdsl_body.append(' XGL_SAMPLER *pSampler = (XGL_SAMPLER *) &pPacket->pSetLayoutInfoList->immutableSampler;')
2949 cdsl_body.append(' *pSampler = saveSampler;')
2950 cdsl_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2951 return "\n".join(cdsl_body)
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2952
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2953 def _gen_replay_create_graphics_pipeline(self):
2954 cgp_body = []
2955 cgp_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')
2956 cgp_body.append(' struct shaderPair saveShader[10];')
2957 cgp_body.append(' unsigned int idx = 0;')
2958 cgp_body.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]2959 cgp_body.append(' createInfo.lastSetLayout = remap(createInfo.lastSetLayout);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2960 cgp_body.append(' // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')
2961 cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')
2962 cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')
2963 cgp_body.append(' while (XGL_NULL_HANDLE != pPacketNext)')
2964 cgp_body.append(' {')
2965 cgp_body.append(' if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')
2966 cgp_body.append(' {')
2967 cgp_body.append(' saveShader[idx].val = pNext->shader.shader;')
2968 cgp_body.append(' saveShader[idx++].addr = &(pNext->shader.shader);')
2969 cgp_body.append(' pNext->shader.shader = remap(pPacketNext->shader.shader);')
2970 cgp_body.append(' }')
2971 cgp_body.append(' pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')
2972 cgp_body.append(' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')
2973 cgp_body.append(' }')
2974 cgp_body.append(' XGL_PIPELINE pipeline;')
2975 cgp_body.append(' replayResult = m_xglFuncs.real_xglCreateGraphicsPipeline(remap(pPacket->device), &createInfo, &pipeline);')
2976 cgp_body.append(' if (replayResult == XGL_SUCCESS)')
2977 cgp_body.append(' {')
2978 cgp_body.append(' add_to_map(pPacket->pPipeline, &pipeline);')
2979 cgp_body.append(' }')
2980 cgp_body.append(' for (unsigned int i = 0; i < idx; i++)')
2981 cgp_body.append(' *(saveShader[i].addr) = saveShader[i].val;')
2982 return "\n".join(cgp_body)
2983
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]2984 def _gen_replay_cmd_wait_events(self):
2985 cwe_body = []
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]2986 cwe_body.append(' XGL_EVENT saveEvent[100];')
2987 cwe_body.append(' uint32_t idx, numRemapBuf=0, numRemapImg=0;')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]2988 cwe_body.append(' assert(pPacket->pWaitInfo && pPacket->pWaitInfo->eventCount <= 100);')
2989 cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->eventCount; idx++)')
2990 cwe_body.append(' {')
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]2991 cwe_body.append(' XGL_EVENT *pEvent = (XGL_EVENT *) &(pPacket->pWaitInfo->pEvents[idx]);')
2992 cwe_body.append(' saveEvent[idx] = pPacket->pWaitInfo->pEvents[idx];')
2993 cwe_body.append(' *pEvent = remap(pPacket->pWaitInfo->pEvents[idx]);')
2994 cwe_body.append(' }')
2995 cwe_body.append('')
2996 cwe_body.append(' XGL_BUFFER saveBuf[100];')
2997 cwe_body.append(' XGL_IMAGE saveImg[100];')
2998 cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->memBarrierCount; idx++)')
2999 cwe_body.append(' {')
3000 cwe_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
3001 cwe_body.append(' assert(pNext);')
3002 cwe_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
3003 cwe_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
3004 cwe_body.append(' assert(numRemapBuf < 100);')
3005 cwe_body.append(' saveBuf[numRemapBuf++] = pNextBuf->buffer;')
3006 cwe_body.append(' pNextBuf->buffer = remap(pNextBuf->buffer);')
3007 cwe_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
3008 cwe_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
3009 cwe_body.append(' assert(numRemapImg < 100);')
3010 cwe_body.append(' saveImg[numRemapImg++] = pNextImg->image;')
3011 cwe_body.append(' pNextImg->image = remap(pNextImg->image);')
3012 cwe_body.append(' }')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]3013 cwe_body.append(' }')
3014 cwe_body.append(' m_xglFuncs.real_xglCmdWaitEvents(remap(pPacket->cmdBuffer), pPacket->pWaitInfo);')
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]3015 cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->memBarrierCount; idx++) {')
3016 cwe_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
3017 cwe_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
3018 cwe_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
3019 cwe_body.append(' pNextBuf->buffer = saveBuf[idx];')
3020 cwe_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
3021 cwe_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
3022 cwe_body.append(' pNextImg->image = saveImg[idx];')
3023 cwe_body.append(' }')
3024 cwe_body.append(' }')
3025 cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->eventCount; idx++) {')
3026 cwe_body.append(' XGL_EVENT *pEvent = (XGL_EVENT *) &(pPacket->pWaitInfo->pEvents[idx]);')
3027 cwe_body.append(' *pEvent = saveEvent[idx];')
3028 cwe_body.append(' }')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]3029 return "\n".join(cwe_body)
3030
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]3031 def _gen_replay_cmd_pipeline_barrier(self):
3032 cpb_body = []
3033 cpb_body.append(' uint32_t idx, numRemapBuf=0, numRemapImg=0;')
3034 cpb_body.append(' XGL_BUFFER saveBuf[100];')
3035 cpb_body.append(' XGL_IMAGE saveImg[100];')
3036 cpb_body.append(' for (idx = 0; idx < pPacket->pBarrier->memBarrierCount; idx++)')
3037 cpb_body.append(' {')
3038 cpb_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
3039 cpb_body.append(' assert(pNext);')
3040 cpb_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
3041 cpb_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
3042 cpb_body.append(' assert(numRemapBuf < 100);')
3043 cpb_body.append(' saveBuf[numRemapBuf++] = pNextBuf->buffer;')
3044 cpb_body.append(' pNextBuf->buffer = remap(pNextBuf->buffer);')
3045 cpb_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
3046 cpb_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
3047 cpb_body.append(' assert(numRemapImg < 100);')
3048 cpb_body.append(' saveImg[numRemapImg++] = pNextImg->image;')
3049 cpb_body.append(' pNextImg->image = remap(pNextImg->image);')
3050 cpb_body.append(' }')
3051 cpb_body.append(' }')
3052 cpb_body.append(' m_xglFuncs.real_xglCmdPipelineBarrier(remap(pPacket->cmdBuffer), pPacket->pBarrier);')
3053 cpb_body.append(' for (idx = 0; idx < pPacket->pBarrier->memBarrierCount; idx++) {')
3054 cpb_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
3055 cpb_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
3056 cpb_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
3057 cpb_body.append(' pNextBuf->buffer = saveBuf[idx];')
3058 cpb_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
3059 cpb_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
3060 cpb_body.append(' pNextImg->image = saveImg[idx];')
3061 cpb_body.append(' }')
3062 cpb_body.append(' }')
3063 return "\n".join(cpb_body)
3064
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]3065 def _gen_replay_create_framebuffer(self):
3066 cf_body = []
3067 cf_body.append(' XGL_FRAMEBUFFER_CREATE_INFO *pInfo = (XGL_FRAMEBUFFER_CREATE_INFO *) pPacket->pCreateInfo;')
3068 cf_body.append(' XGL_COLOR_ATTACHMENT_BIND_INFO *pColorAttachments, *pSavedColor = (XGL_COLOR_ATTACHMENT_BIND_INFO*)pInfo->pColorAttachments;')
3069 cf_body.append(' bool allocatedColorAttachments = false;')
3070 cf_body.append(' if (pSavedColor != NULL)')
3071 cf_body.append(' {')
3072 cf_body.append(' allocatedColorAttachments = true;')
3073 cf_body.append(' pColorAttachments = GLV_NEW_ARRAY(XGL_COLOR_ATTACHMENT_BIND_INFO, pInfo->colorAttachmentCount);')
3074 cf_body.append(' memcpy(pColorAttachments, pSavedColor, sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) * pInfo->colorAttachmentCount);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]3075 cf_body.append(' for (uint32_t i = 0; i < pInfo->colorAttachmentCount; i++)')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]3076 cf_body.append(' {')
3077 cf_body.append(' pColorAttachments[i].view = remap(pInfo->pColorAttachments[i].view);')
3078 cf_body.append(' }')
3079 cf_body.append(' pInfo->pColorAttachments = pColorAttachments;')
3080 cf_body.append(' }')
3081 cf_body.append(' // remap depth stencil target')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]3082 cf_body.append(' const XGL_DEPTH_STENCIL_BIND_INFO *pSavedDS = pInfo->pDepthStencilAttachment;')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]3083 cf_body.append(' XGL_DEPTH_STENCIL_BIND_INFO depthTarget;')
3084 cf_body.append(' if (pSavedDS != NULL)')
3085 cf_body.append(' {')
3086 cf_body.append(' memcpy(&depthTarget, pSavedDS, sizeof(XGL_DEPTH_STENCIL_BIND_INFO));')
3087 cf_body.append(' depthTarget.view = remap(pSavedDS->view);')
3088 cf_body.append(' pInfo->pDepthStencilAttachment = &depthTarget;')
3089 cf_body.append(' }')
3090 cf_body.append(' XGL_FRAMEBUFFER local_framebuffer;')
3091 cf_body.append(' replayResult = m_xglFuncs.real_xglCreateFramebuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_framebuffer);')
3092 cf_body.append(' pInfo->pColorAttachments = pSavedColor;')
3093 cf_body.append(' pInfo->pDepthStencilAttachment = pSavedDS;')
3094 cf_body.append(' if (replayResult == XGL_SUCCESS)')
3095 cf_body.append(' {')
3096 cf_body.append(' add_to_map(pPacket->pFramebuffer, &local_framebuffer);')
3097 cf_body.append(' }')
3098 cf_body.append(' if (allocatedColorAttachments)')
3099 cf_body.append(' {')
3100 cf_body.append(' GLV_DELETE((void*)pColorAttachments);')
3101 cf_body.append(' }')
3102 return "\n".join(cf_body)
3103
3104 def _gen_replay_create_renderpass(self):
3105 cr_body = []
3106 cr_body.append(' XGL_RENDER_PASS_CREATE_INFO *pInfo = (XGL_RENDER_PASS_CREATE_INFO *) pPacket->pCreateInfo;')
3107 cr_body.append(' // remap framebuffer')
Jon Ashburnfc5c85c2015-03-09 11:33:40 -0600[diff] [blame]3108 cr_body.append(' XGL_FRAMEBUFFER savedFB = 0, *pFB = &(pInfo->framebuffer);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]3109 cr_body.append(' if (*pFB != NULL)')
3110 cr_body.append(' {')
3111 cr_body.append(' savedFB = pInfo->framebuffer;')
3112 cr_body.append(' *pFB = remap(pInfo->framebuffer);')
3113 cr_body.append(' }')
3114 cr_body.append(' XGL_RENDER_PASS local_renderpass;')
3115 cr_body.append(' replayResult = m_xglFuncs.real_xglCreateRenderPass(remap(pPacket->device), pPacket->pCreateInfo, &local_renderpass);')
Jon Ashburnfc5c85c2015-03-09 11:33:40 -0600[diff] [blame]3116 cr_body.append(' if (*pFB != NULL)')
3117 cr_body.append(' pInfo->framebuffer = savedFB;')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]3118 cr_body.append(' if (replayResult == XGL_SUCCESS)')
3119 cr_body.append(' {')
3120 cr_body.append(' add_to_map(pPacket->pRenderPass, &local_renderpass);')
3121 cr_body.append(' }')
3122 return "\n".join(cr_body)
3123
3124 def _gen_replay_begin_command_buffer(self):
3125 bcb_body = []
3126 bcb_body.append(' XGL_CMD_BUFFER_BEGIN_INFO* pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*)pPacket->pBeginInfo;')
3127 bcb_body.append(' // assume only zero or one graphics_begin_info in the chain')
3128 bcb_body.append(' XGL_RENDER_PASS savedRP, *pRP;')
3129 bcb_body.append(' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *pGInfo = NULL;')
3130 bcb_body.append(' while (pInfo != NULL)')
3131 bcb_body.append(' {')
3132 bcb_body.append('')
3133 bcb_body.append(' if (pInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO)')
3134 bcb_body.append(' {')
3135 bcb_body.append(' pGInfo = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *) pInfo;')
3136 bcb_body.append(' savedRP = pGInfo->renderPass;')
3137 bcb_body.append(' pRP = &(pGInfo->renderPass);')
3138 bcb_body.append(' *pRP = remap(pGInfo->renderPass);')
3139 bcb_body.append(' break;')
3140 bcb_body.append(' }')
3141 bcb_body.append(' pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*) pInfo->pNext;')
3142 bcb_body.append(' }')
3143 bcb_body.append(' replayResult = m_xglFuncs.real_xglBeginCommandBuffer(remap(pPacket->cmdBuffer), pPacket->pBeginInfo);')
3144 bcb_body.append(' if (pGInfo != NULL)')
3145 bcb_body.append(' pGInfo->renderPass = savedRP;')
3146 return "\n".join(bcb_body)
3147
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3148 def _gen_replay_store_pipeline(self):
3149 sp_body = []
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]3150 sp_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3151 sp_body.append(' void* pData = NULL;')
3152 sp_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
3153 sp_body.append(' {')
3154 sp_body.append(' size = *pPacket->pDataSize;')
3155 sp_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
3156 sp_body.append(' }')
3157 sp_body.append(' replayResult = m_xglFuncs.real_xglStorePipeline(remap(pPacket->pipeline), &size, pData);')
3158 sp_body.append(' if (replayResult == XGL_SUCCESS)')
3159 sp_body.append(' {')
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]3160 sp_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3161 sp_body.append(' {')
3162 sp_body.append(' glv_LogWarn("xglStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
3163 sp_body.append(' }')
3164 sp_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
3165 sp_body.append(' {')
3166 sp_body.append(' glv_LogWarn("xglStorePipeline returned differing data contents than the trace file contained.\\n");')
3167 sp_body.append(' }')
3168 sp_body.append(' }')
3169 sp_body.append(' glv_free(pData);')
3170 return "\n".join(sp_body)
3171
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3172 def _gen_replay_get_multi_gpu_compatibility(self):
3173 gmgc_body = []
3174 gmgc_body.append(' XGL_GPU_COMPATIBILITY_INFO cInfo;')
3175 gmgc_body.append(' XGL_PHYSICAL_GPU handle0, handle1;')
3176 gmgc_body.append(' handle0 = remap(pPacket->gpu0);')
3177 gmgc_body.append(' handle1 = remap(pPacket->gpu1);')
3178 gmgc_body.append(' replayResult = m_xglFuncs.real_xglGetMultiGpuCompatibility(handle0, handle1, &cInfo);')
3179 return "\n".join(gmgc_body)
3180
3181 def _gen_replay_destroy_object(self):
3182 do_body = []
3183 do_body.append(' XGL_OBJECT object = remap(pPacket->object);')
3184 do_body.append(' if (object != XGL_NULL_HANDLE)')
3185 do_body.append(' replayResult = m_xglFuncs.real_xglDestroyObject(object);')
3186 do_body.append(' if (replayResult == XGL_SUCCESS)')
3187 do_body.append(' rm_from_map(pPacket->object);')
3188 return "\n".join(do_body)
3189
3190 def _gen_replay_wait_for_fences(self):
3191 wf_body = []
3192 wf_body.append(' XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]3193 wf_body.append(' for (uint32_t i = 0; i < pPacket->fenceCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3194 wf_body.append(' {')
3195 wf_body.append(' *(pFence + i) = remap(*(pPacket->pFences + i));')
3196 wf_body.append(' }')
3197 wf_body.append(' replayResult = m_xglFuncs.real_xglWaitForFences(remap(pPacket->device), pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);')
3198 wf_body.append(' GLV_DELETE(pFence);')
3199 return "\n".join(wf_body)
3200
3201 def _gen_replay_wsi_associate_connection(self):
3202 wac_body = []
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3203 wac_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3204 wac_body.append(' //associate with the replayers Wsi connection rather than tracers')
3205 wac_body.append(' replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3206 wac_body.append('#elif defined(WIN32)')
3207 wac_body.append(' //TBD')
3208 wac_body.append(' replayResult = XGL_SUCCESS;')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]3209 wac_body.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3210 return "\n".join(wac_body)
3211
3212 def _gen_replay_wsi_get_msc(self):
3213 wgm_body = []
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3214 wgm_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
3215 wgm_body.append(' xcb_window_t window = m_display->m_XcbWindow;')
3216 wgm_body.append(' replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);')
3217 wgm_body.append('#elif defined(WIN32)')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]3218 wgm_body.append(' //TBD')
3219 wgm_body.append(' replayResult = XGL_SUCCESS;')
3220 wgm_body.append('#else')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3221
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]3222 wgm_body.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3223 return "\n".join(wgm_body)
3224
3225 def _gen_replay_wsi_create_presentable_image(self):
3226 cpi_body = []
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3227 cpi_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]3228 cpi_body.append(' struct imageObj local_imgObj;')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3229 cpi_body.append(' struct gpuMemObj local_mem;')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]3230 cpi_body.append(' m_display->imageHeight.push_back(pPacket->pCreateInfo->extent.height);')
3231 cpi_body.append(' m_display->imageWidth.push_back(pPacket->pCreateInfo->extent.width);')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3232 cpi_body.append(' replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &local_imgObj.replayImage, &local_mem.replayGpuMem);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3233 cpi_body.append(' if (replayResult == XGL_SUCCESS)')
3234 cpi_body.append(' {')
3235 cpi_body.append(' if (pPacket->pImage != NULL)')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]3236 cpi_body.append(' add_to_map(pPacket->pImage, &local_imgObj);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3237 cpi_body.append(' if(pPacket->pMem != NULL)')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]3238 cpi_body.append(' add_to_map(pPacket->pMem, &local_mem);')
3239 cpi_body.append(' m_display->imageHandles.push_back(local_imgObj.replayImage);')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3240 cpi_body.append(' m_display->imageMemory.push_back(local_mem.replayGpuMem);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3241 cpi_body.append(' }')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3242 cpi_body.append('#elif defined(WIN32)')
3243 cpi_body.append(' //TBD')
3244 cpi_body.append(' replayResult = XGL_SUCCESS;')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]3245 cpi_body.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3246 return "\n".join(cpi_body)
3247
3248 def _gen_replay_wsi_queue_present(self):
3249 wqp_body = []
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3250 wqp_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3251 wqp_body.append(' XGL_WSI_X11_PRESENT_INFO pInfo;')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]3252 wqp_body.append(' std::vector<int>::iterator it;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3253 wqp_body.append(' memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')
3254 wqp_body.append(' pInfo.srcImage = remap(pPacket->pPresentInfo->srcImage);')
3255 wqp_body.append(' // use replayers Xcb window')
3256 wqp_body.append(' pInfo.destWindow = m_display->m_XcbWindow;')
3257 wqp_body.append(' replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(remap(pPacket->queue), &pInfo, remap(pPacket->fence));')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]3258 wqp_body.append(' it = std::find(m_screenshotFrames.begin(), m_screenshotFrames.end(), m_display->m_frameNumber);')
3259 wqp_body.append(' if (it != m_screenshotFrames.end())')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]3260 wqp_body.append(' {')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]3261 wqp_body.append(' for(unsigned int i=0; i<m_display->imageHandles.size(); i++)')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]3262 wqp_body.append(' {')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]3263 wqp_body.append(' if (m_display->imageHandles[i] == pInfo.srcImage)')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]3264 wqp_body.append(' {')
3265 wqp_body.append(' char frameName[32];')
3266 wqp_body.append(' sprintf(frameName, "%d",m_display->m_frameNumber);')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]3267 wqp_body.append(' glvWritePPM(frameName, m_display->imageWidth[i], m_display->imageHeight[i],')
3268 wqp_body.append(' m_display->imageHandles[i], m_display->imageMemory[i], &m_xglFuncs);')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]3269 wqp_body.append(' break;')
3270 wqp_body.append(' }')
3271 wqp_body.append(' }')
3272 wqp_body.append(' }')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3273 wqp_body.append('#elif defined(WIN32)')
3274 wqp_body.append(' //TBD')
3275 wqp_body.append(' replayResult = XGL_SUCCESS;')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]3276 wqp_body.append('#endif')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]3277 wqp_body.append(' m_display->m_frameNumber++;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3278 return "\n".join(wqp_body)
3279
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3280 def _gen_replay_alloc_memory(self):
3281 am_body = []
3282 am_body.append(' struct gpuMemObj local_mem;')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]3283 am_body.append(' if (!m_adjustForGPU)')
3284 am_body.append(' replayResult = m_xglFuncs.real_xglAllocMemory(remap(pPacket->device), pPacket->pAllocInfo, &local_mem.replayGpuMem);')
3285 am_body.append(' if (replayResult == XGL_SUCCESS || m_adjustForGPU)')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3286 am_body.append(' {')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]3287 am_body.append(' local_mem.pGpuMem = new (gpuMemory);')
3288 am_body.append(' if (local_mem.pGpuMem)')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]3289 am_body.append(' local_mem.pGpuMem->setAllocInfo(pPacket->pAllocInfo, m_adjustForGPU);')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3290 am_body.append(' add_to_map(pPacket->pMem, &local_mem);')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3291 am_body.append(' }')
3292 return "\n".join(am_body)
3293
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3294 def _gen_replay_free_memory(self):
3295 fm_body = []
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]3296 fm_body.append(' struct gpuMemObj local_mem;')
3297 fm_body.append(' local_mem = m_gpuMemorys.find(pPacket->mem)->second;')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]3298 fm_body.append(' // TODO how/when to free pendingAlloc that did not use and existing gpuMemObj')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]3299 fm_body.append(' replayResult = m_xglFuncs.real_xglFreeMemory(local_mem.replayGpuMem);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3300 fm_body.append(' if (replayResult == XGL_SUCCESS) ')
3301 fm_body.append(' {')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]3302 fm_body.append(' delete local_mem.pGpuMem;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3303 fm_body.append(' rm_from_map(pPacket->mem);')
3304 fm_body.append(' }')
3305 return "\n".join(fm_body)
3306
3307 def _gen_replay_map_memory(self):
3308 mm_body = []
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]3309 mm_body.append(' struct gpuMemObj local_mem = m_gpuMemorys.find(pPacket->mem)->second;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]3310 mm_body.append(' void* pData;')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]3311 mm_body.append(' if (!local_mem.pGpuMem->isPendingAlloc())')
3312 mm_body.append(' {')
3313 mm_body.append(' replayResult = m_xglFuncs.real_xglMapMemory(local_mem.replayGpuMem, pPacket->flags, &pData);')
3314 mm_body.append(' if (replayResult == XGL_SUCCESS)')
3315 mm_body.append(' {')
3316 mm_body.append(' if (local_mem.pGpuMem)')
3317 mm_body.append(' local_mem.pGpuMem->setMemoryMapRange(pData, 0, 0, false);')
3318 mm_body.append(' }')
3319 mm_body.append(' } else')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]3320 mm_body.append(' {')
3321 mm_body.append(' if (local_mem.pGpuMem)')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]3322 mm_body.append(' local_mem.pGpuMem->setMemoryMapRange(NULL, 0, 0, true);')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]3323 mm_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3324 return "\n".join(mm_body)
3325
3326 def _gen_replay_unmap_memory(self):
3327 um_body = []
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]3328 um_body.append(' struct gpuMemObj local_mem = m_gpuMemorys.find(pPacket->mem)->second;')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]3329 um_body.append(' if (!local_mem.pGpuMem->isPendingAlloc())')
3330 um_body.append(' {')
3331 um_body.append(' if (local_mem.pGpuMem)')
3332 um_body.append(' local_mem.pGpuMem->copyMappingData(pPacket->pData); // copies data from packet into memory buffer')
3333 um_body.append(' replayResult = m_xglFuncs.real_xglUnmapMemory(local_mem.replayGpuMem);')
3334 um_body.append(' } else')
3335 um_body.append(' {')
3336 um_body.append(' if (local_mem.pGpuMem)')
3337 um_body.append(' {')
3338 um_body.append(' unsigned char *pBuf = (unsigned char *) glv_malloc(local_mem.pGpuMem->getMemoryMapSize());')
3339 um_body.append(' if (!pBuf)')
3340 um_body.append(' glv_LogError("vkUnmapMemory() malloc failed");')
3341 um_body.append(' local_mem.pGpuMem->setMemoryDataAddr(pBuf);')
3342 um_body.append(' local_mem.pGpuMem->copyMappingData(pPacket->pData);')
3343 um_body.append(' }')
3344 um_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3345 return "\n".join(um_body)
3346
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3347 def _gen_replay_pin_system_memory(self):
3348 psm_body = []
3349 psm_body.append(' struct gpuMemObj local_mem;')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame^]3350 psm_body.append(' /* TODO do we need to skip (make pending) this call for m_adjustForGPU */')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3351 psm_body.append(' replayResult = m_xglFuncs.real_xglPinSystemMemory(remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_mem.replayGpuMem);')
3352 psm_body.append(' if (replayResult == XGL_SUCCESS)')
3353 psm_body.append(' add_to_map(pPacket->pMem, &local_mem);')
3354 return "\n".join(psm_body)
3355
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3356 def _gen_replay_bind_dynamic_memory_view(self):
3357 bdmv_body = []
3358 bdmv_body.append(' XGL_MEMORY_VIEW_ATTACH_INFO memView;')
3359 bdmv_body.append(' memcpy(&memView, pPacket->pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));')
3360 bdmv_body.append(' memView.mem = remap(pPacket->pMemView->mem);')
3361 bdmv_body.append(' m_xglFuncs.real_xglCmdBindDynamicMemoryView(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);')
3362 return "\n".join(bdmv_body)
3363
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]3364 # Generate main replay case statements where actual replay API call is dispatched based on input packet data
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3365 def _generate_replay(self):
3366 # map protos to custom functions if body is fully custom
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]3367 custom_body_dict = {'EnumerateGpus': self._gen_replay_enum_gpus,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3368 'GetGpuInfo': self._gen_replay_get_gpu_info,
3369 'CreateDevice': self._gen_replay_create_device,
3370 'GetExtensionSupport': self._gen_replay_get_extension_support,
3371 'QueueSubmit': self._gen_replay_queue_submit,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3372 'GetObjectInfo': self._gen_replay_get_object_info,
3373 'GetFormatInfo': self._gen_replay_get_format_info,
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]3374 'CreateImage': self._gen_replay_create_image,
3375 'CreateBuffer': self._gen_replay_create_buffer,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3376 'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,
3377 'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]3378 'CreateFramebuffer': self._gen_replay_create_framebuffer,
3379 'CreateRenderPass': self._gen_replay_create_renderpass,
3380 'BeginCommandBuffer': self._gen_replay_begin_command_buffer,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3381 'StorePipeline': self._gen_replay_store_pipeline,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3382 'GetMultiGpuCompatibility': self._gen_replay_get_multi_gpu_compatibility,
3383 'DestroyObject': self._gen_replay_destroy_object,
3384 'WaitForFences': self._gen_replay_wait_for_fences,
3385 'WsiX11AssociateConnection': self._gen_replay_wsi_associate_connection,
3386 'WsiX11GetMSC': self._gen_replay_wsi_get_msc,
3387 'WsiX11CreatePresentableImage': self._gen_replay_wsi_create_presentable_image,
3388 'WsiX11QueuePresent': self._gen_replay_wsi_queue_present,
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3389 'AllocMemory': self._gen_replay_alloc_memory,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3390 'FreeMemory': self._gen_replay_free_memory,
3391 'MapMemory': self._gen_replay_map_memory,
3392 'UnmapMemory': self._gen_replay_unmap_memory,
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]3393 'PinSystemMemory': self._gen_replay_pin_system_memory,
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]3394 'CmdBindDynamicMemoryView': self._gen_replay_bind_dynamic_memory_view,
3395 'UpdateDescriptors': self._gen_replay_update_descriptors,
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]3396 'CreateDescriptorSetLayout': self._gen_replay_create_descriptor_set_layout,
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]3397 'CmdWaitEvents': self._gen_replay_cmd_wait_events,
3398 'CmdPipelineBarrier': self._gen_replay_cmd_pipeline_barrier}
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]3399 # TODO : Need to guard CreateInstance with "if (!m_display->m_initedXGL)" check
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3400 # Despite returning a value, don't check these funcs b/c custom code includes check already
Jon Ashburnb1b63ed2015-02-03 11:24:08 -0700[diff] [blame]3401 custom_check_ret_val = ['EnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3402 # multi-gpu Open funcs w/ list of local params to create
3403 custom_open_params = {'OpenSharedMemory': (-1,),
3404 'OpenSharedQueueSemaphore': (-1,),
3405 'OpenPeerMemory': (-1,),
3406 'OpenPeerImage': (-1, -2,)}
3407 # Functions that create views are unique from other create functions
Jon Ashburnb1b63ed2015-02-03 11:24:08 -0700[diff] [blame]3408 create_view_list = ['CreateBufferView', 'CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3409 # Functions to treat as "Create' that don't have 'Create' in the name
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]3410 special_create_list = ['LoadPipeline', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocDescriptorSets']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3411 # A couple funcs use do while loops
3412 do_while_dict = {'GetFenceStatus': 'replayResult != pPacket->result && pPacket->result == XGL_SUCCESS', 'GetEventStatus': '(pPacket->result == XGL_EVENT_SET || pPacket->result == XGL_EVENT_RESET) && replayResult != pPacket->result'}
3413 rbody = []
3414 rbody.append('#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);\n')
3415 rbody.append('glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)')
3416 rbody.append('{')
3417 rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')
3418 rbody.append(' XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;')
3419 rbody.append(' switch (packet->packet_id)')
3420 rbody.append(' {')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]3421 rbody.append(' case GLV_TPI_XGL_xglApiVersion:')
3422 rbody.append(' break; // nothing to replay on the version packet')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3423 for proto in self.protos:
3424 ret_value = False
3425 create_view = False
3426 create_func = False
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]3427 # TODO : How to handle void* return of GetProcAddr?
3428 if ('void' not in proto.ret) and (proto.name not in custom_check_ret_val):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3429 ret_value = True
3430 if proto.name in create_view_list:
3431 create_view = True
3432 elif 'Create' in proto.name or proto.name in special_create_list:
3433 create_func = True
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3434 rbody.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)
3435 rbody.append(' {')
3436 rbody.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(packet->pBody);' % (proto.name, proto.name))
3437 if proto.name in custom_body_dict:
3438 rbody.append(custom_body_dict[proto.name]())
3439 else:
3440 if proto.name in custom_open_params:
3441 rbody.append(' XGL_DEVICE handle;')
3442 for pidx in custom_open_params[proto.name]:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]3443 rbody.append(' %s local_%s;' % (proto.params[pidx].ty.replace('const ', '').strip('*'), proto.params[pidx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3444 rbody.append(' handle = remap(pPacket->device);')
3445 elif create_view:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]3446 rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').replace('const ', '')))
3447 rbody.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(%s));' % (proto.params[1].ty.strip('*').replace('const ', '')))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3448 if 'CreateComputePipeline' == proto.name:
3449 rbody.append(' createInfo.cs.shader = remap(pPacket->pCreateInfo->cs.shader);')
Jon Ashburnb1b63ed2015-02-03 11:24:08 -0700[diff] [blame]3450 elif 'CreateBufferView' == proto.name:
3451 rbody.append(' createInfo.buffer = remap(pPacket->pCreateInfo->buffer);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3452 else:
3453 rbody.append(' createInfo.image = remap(pPacket->pCreateInfo->image);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]3454 rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3455 elif create_func: # Declare local var to store created handle into
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]3456 rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]3457 if 'AllocDescriptorSets' == proto.name:
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]3458 rbody.append(' %s local_%s[100];' % (proto.params[-2].ty.strip('*').replace('const ', ''), proto.params[-2].name))
3459 rbody.append(' XGL_DESCRIPTOR_SET_LAYOUT localDescSets[100];')
3460 rbody.append(' assert(pPacket->count <= 100);')
3461 rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')
3462 rbody.append(' {')
3463 rbody.append(' localDescSets[i] = remap(pPacket->%s[i]);' % (proto.params[-3].name))
3464 rbody.append(' }')
3465 elif proto.name == 'ClearDescriptorSets':
3466 rbody.append(' XGL_DESCRIPTOR_SET localDescSets[100];')
3467 rbody.append(' assert(pPacket->count <= 100);')
3468 rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3469 rbody.append(' {')
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]3470 rbody.append(' localDescSets[i] = remap(pPacket->%s[i]);' % (proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3471 rbody.append(' }')
3472 elif proto.name in do_while_dict:
3473 rbody.append(' do {')
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]3474 elif proto.name == 'EnumerateLayers':
3475 rbody.append(' char **bufptr = GLV_NEW_ARRAY(char *, pPacket->maxLayerCount);')
3476 rbody.append(' char **ptrLayers = (pPacket->pOutLayers == NULL) ? bufptr : (char **) pPacket->pOutLayers;')
3477 rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')
3478 rbody.append(' bufptr[i] = GLV_NEW_ARRAY(char, pPacket->maxStringSize);')
Jon Ashburnd698ca22015-02-12 12:37:46 -0700[diff] [blame]3479 elif proto.name == 'DestroyInstance':
3480 rbody.append(' xglDbgUnregisterMsgCallback(g_fpDbgMsgCallback);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3481 rr_string = ' '
3482 if ret_value:
3483 rr_string = ' replayResult = '
3484 rr_string += 'm_xglFuncs.real_xgl%s(' % proto.name
3485 for p in proto.params:
3486 # For last param of Create funcs, pass address of param
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]3487 if create_func:
3488 if p.name == proto.params[-1].name:
3489 rr_string += '&local_%s, ' % p.name
3490 elif proto.name == 'AllocDescriptorSets' and p.name == proto.params[-2].name:
3491 rr_string += 'local_%s, ' % p.name
3492 else:
3493 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3494 else:
3495 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
3496 rr_string = '%s);' % rr_string[:-2]
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]3497 if proto.name in custom_open_params:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3498 rr_list = rr_string.split(', ')
3499 rr_list[0] = rr_list[0].replace('remap(pPacket->device)', 'handle')
3500 for pidx in custom_open_params[proto.name]:
3501 rr_list[pidx] = '&local_%s' % proto.params[pidx].name
3502 rr_string = ', '.join(rr_list)
3503 rr_string += ');'
3504 elif create_view:
3505 rr_list = rr_string.split(', ')
3506 rr_list[-2] = '&createInfo'
3507 rr_list[-1] = '&local_%s);' % proto.params[-1].name
3508 rr_string = ', '.join(rr_list)
3509 # this is a sneaky shortcut to use generic create code below to add_to_map
3510 create_func = True
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]3511 elif proto.name == 'EnumerateLayers':
3512 rr_string = rr_string.replace('pPacket->pOutLayers', 'ptrLayers')
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]3513 elif proto.name == 'ClearDescriptorSets':
3514 rr_string = rr_string.replace('pPacket->pDescriptorSets', 'localDescSets')
3515 elif proto.name == 'AllocDescriptorSets':
3516 rr_string = rr_string.replace('pPacket->pSetLayouts', 'localDescSets')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3517 rbody.append(rr_string)
3518 if 'DestroyDevice' in proto.name:
3519 rbody.append(' if (replayResult == XGL_SUCCESS)')
3520 rbody.append(' {')
Peter Lohrmann53e89242015-02-27 15:35:15 -0800[diff] [blame]3521 rbody.append(' m_pCBDump = NULL;')
3522 rbody.append(' m_pDSDump = NULL;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3523 rbody.append(' rm_from_map(pPacket->device);')
3524 rbody.append(' m_display->m_initedXGL = false;')
3525 rbody.append(' }')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]3526 if 'DestroyInstance' in proto.name:
3527 rbody.append(' if (replayResult == XGL_SUCCESS)')
3528 rbody.append(' {')
Jon Ashburn6f58a162015-02-03 09:17:12 -0700[diff] [blame]3529 rbody.append(' // TODO need to handle multiple instances and only clearing maps within an instance.')
3530 rbody.append(' // TODO this only works with a single instance used at any given time.')
3531 rbody.append(' clear_all_map_handles();')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]3532 rbody.append(' }')
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]3533 elif 'AllocDescriptorSets' in proto.name:
3534 rbody.append(' if (replayResult == XGL_SUCCESS)')
3535 rbody.append(' {')
3536 rbody.append(' for (uint32_t i = 0; i < local_pCount; i++) {')
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]3537 rbody.append(' add_to_map(&pPacket->%s[i], &local_%s[i]);' % (proto.params[-2].name, proto.params[-2].name))
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]3538 rbody.append(' }')
3539 rbody.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3540 elif create_func: # save handle mapping if create successful
3541 rbody.append(' if (replayResult == XGL_SUCCESS)')
3542 rbody.append(' {')
3543 rbody.append(' add_to_map(pPacket->%s, &local_%s);' % (proto.params[-1].name, proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3544 rbody.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3545 elif proto.name in do_while_dict:
3546 rbody[-1] = ' %s' % rbody[-1]
3547 rbody.append(' } while (%s);' % do_while_dict[proto.name])
Jon Ashburn8bead7a2015-02-23 11:07:30 -0700[diff] [blame]3548 rbody.append(' if (pPacket->result != XGL_NOT_READY || replayResult != XGL_SUCCESS)')
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]3549 elif proto.name == 'EnumerateLayers':
3550 rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')
3551 rbody.append(' GLV_DELETE(bufptr[i]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3552 if ret_value:
3553 rbody.append(' CHECK_RETURN_VALUE(xgl%s);' % proto.name)
3554 if 'MsgCallback' in proto.name:
3555 rbody.pop()
3556 rbody.pop()
3557 rbody.pop()
3558 rbody.append(' // Just eating these calls as no way to restore dbg func ptr.')
3559 rbody.append(' break;')
3560 rbody.append(' }')
3561 rbody.append(' default:')
3562 rbody.append(' glv_LogWarn("Unrecognized packet_id %u, skipping\\n", packet->packet_id);')
3563 rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')
3564 rbody.append(' break;')
3565 rbody.append(' }')
3566 rbody.append(' return returnValue;')
3567 rbody.append('}')
3568 return "\n".join(rbody)
3569
3570class GlaveTraceHeader(Subcommand):
3571 def generate_header(self):
3572 header_txt = []
3573 header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
3574 header_txt.append('#include "glvtrace_xgl_packet_id.h"\n')
3575 header_txt.append('void AttachHooks();')
3576 header_txt.append('void DetachHooks();')
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]3577 header_txt.append('void InitTracer(void);\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3578 return "\n".join(header_txt)
3579
3580 def generate_body(self):
3581 body = [self._generate_trace_func_ptrs(),
3582 self._generate_trace_func_protos()]
3583
3584 return "\n".join(body)
3585
3586class GlaveTraceC(Subcommand):
3587 def generate_header(self):
3588 header_txt = []
3589 header_txt.append('#include "glv_platform.h"')
3590 header_txt.append('#include "glv_common.h"')
3591 header_txt.append('#include "glvtrace_xgl_xgl.h"')
3592 header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
3593 header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
3594 header_txt.append('#include "glv_interconnect.h"')
3595 header_txt.append('#include "glv_filelike.h"')
Tobin Ehlisff765b02015-03-12 14:50:40 -0600[diff] [blame]3596 header_txt.append('#include "xgl_struct_size_helper.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3597 header_txt.append('#ifdef WIN32')
3598 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
3599 header_txt.append('#endif')
3600 header_txt.append('#include "glv_trace_packet_utils.h"')
3601 header_txt.append('#include <stdio.h>\n')
3602 return "\n".join(header_txt)
3603
3604 def generate_body(self):
3605 body = [self._generate_func_ptr_assignments(),
3606 self._generate_attach_hooks(),
3607 self._generate_detach_hooks(),
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]3608 self._generate_init_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3609 self._generate_helper_funcs(),
3610 self._generate_trace_funcs()]
3611
3612 return "\n".join(body)
3613
3614class GlavePacketID(Subcommand):
3615 def generate_header(self):
3616 header_txt = []
3617 header_txt.append('#pragma once\n')
3618 header_txt.append('#include "glv_trace_packet_utils.h"')
3619 header_txt.append('#include "glv_trace_packet_identifiers.h"')
3620 header_txt.append('#include "glv_interconnect.h"')
3621 header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
3622 header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
3623 header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
3624 header_txt.append('#include "xgl_enum_string_helper.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3625 header_txt.append('#if defined(WIN32)')
3626 header_txt.append('#define snprintf _snprintf')
3627 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3628 header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')
3629 header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\\n");\n')
3630 header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')
3631 header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);\n')
3632 header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')
3633 header_txt.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);\n')
3634 header_txt.append('#define FINISH_TRACE_PACKET() \\')
3635 header_txt.append(' glv_finalize_trace_packet(pHeader); \\')
3636 header_txt.append(' glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \\')
3637 header_txt.append(' glv_delete_trace_packet(&pHeader);')
3638 return "\n".join(header_txt)
3639
3640 def generate_body(self):
3641 body = [self._generate_packet_id_enum(),
3642 self._generate_stringify_func(),
3643 self._generate_interp_func()]
3644
3645 return "\n".join(body)
3646
3647class GlaveCoreStructs(Subcommand):
3648 def generate_header(self):
3649 header_txt = []
3650 header_txt.append('#pragma once\n')
3651 header_txt.append('#include "xgl.h"')
3652 header_txt.append('#include "glv_trace_packet_utils.h"\n')
3653 return "\n".join(header_txt)
3654
3655 def generate_body(self):
3656 body = [self._generate_struct_util_funcs(),
3657 self._generate_interp_funcs()]
3658
3659 return "\n".join(body)
3660
3661class GlaveWsiHeader(Subcommand):
3662 def generate_header(self):
3663 header_txt = []
3664 header_txt.append('#pragma once\n')
3665 header_txt.append('#include "xgl.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3666 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3667 header_txt.append('#include "xglWsiX11Ext.h"\n')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]3668 header_txt.append('#else')
3669 header_txt.append('#include "xglWsiWinExt.h"')
3670 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3671 header_txt.append('void AttachHooks_xglwsix11ext();')
3672 header_txt.append('void DetachHooks_xglwsix11ext();')
3673 return "\n".join(header_txt)
3674
3675 def generate_body(self):
3676 body = [self._generate_trace_func_ptrs_ext(),
3677 self._generate_trace_func_protos_ext()]
3678
3679 return "\n".join(body)
3680
3681class GlaveWsiC(Subcommand):
3682 def generate_header(self):
3683 header_txt = []
3684 header_txt.append('#include "glv_platform.h"')
3685 header_txt.append('#include "glv_common.h"')
3686 header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
3687 header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
3688 header_txt.append('#include "glvtrace_xgl_packet_id.h"')
3689 header_txt.append('#ifdef WIN32')
3690 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
3691 header_txt.append('#endif')
3692 return "\n".join(header_txt)
3693
3694 def generate_body(self):
3695 body = [self._generate_func_ptr_assignments_ext(),
3696 self._generate_attach_hooks_ext(),
3697 self._generate_detach_hooks_ext(),
3698 self._generate_trace_funcs_ext()]
3699
3700 return "\n".join(body)
3701
3702class GlaveWsiStructs(Subcommand):
3703 def generate_header(self):
3704 header_txt = []
3705 header_txt.append('#pragma once\n')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3706 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3707 header_txt.append('#include "xglWsiX11Ext.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]3708 header_txt.append('#else')
3709 header_txt.append('#include "xglWsiWinExt.h"')
3710 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3711 header_txt.append('#include "glv_trace_packet_utils.h"\n')
3712 return "\n".join(header_txt)
3713
3714 def generate_body(self):
3715 body = [self._generate_interp_funcs_ext()]
3716
3717 return "\n".join(body)
3718
3719class GlaveDbgHeader(Subcommand):
3720 def generate_header(self):
3721 header_txt = []
3722 header_txt.append('#pragma once\n')
3723 header_txt.append('#include "xgl.h"')
3724 header_txt.append('#include "xglDbg.h"\n')
3725 header_txt.append('void AttachHooks_xgldbg();')
3726 header_txt.append('void DetachHooks_xgldbg();')
3727 return "\n".join(header_txt)
3728
3729 def generate_body(self):
3730 body = [self._generate_trace_func_ptrs_ext('Dbg'),
3731 self._generate_trace_func_protos_ext('Dbg')]
3732
3733 return "\n".join(body)
3734
3735class GlaveDbgC(Subcommand):
3736 def generate_header(self):
3737 header_txt = []
3738 header_txt.append('#include "glv_platform.h"')
3739 header_txt.append('#include "glv_common.h"')
3740 header_txt.append('#include "glvtrace_xgl_xgl.h"')
3741 header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
3742 header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
3743 header_txt.append('#include "glvtrace_xgl_packet_id.h"')
3744 header_txt.append('#ifdef WIN32')
3745 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
3746 header_txt.append('#endif')
3747 return "\n".join(header_txt)
3748
3749 def generate_body(self):
3750 body = [self._generate_func_ptr_assignments_ext('Dbg'),
3751 self._generate_attach_hooks_ext('Dbg'),
3752 self._generate_detach_hooks_ext('Dbg'),
3753 self._generate_trace_funcs_ext('Dbg')]
3754
3755 return "\n".join(body)
3756
3757class GlaveDbgStructs(Subcommand):
3758 def generate_header(self):
3759 header_txt = []
3760 header_txt.append('#pragma once\n')
3761 header_txt.append('#include "xglDbg.h"')
3762 header_txt.append('#include "glv_trace_packet_utils.h"\n')
3763 return "\n".join(header_txt)
3764
3765 def generate_body(self):
3766 body = [self._generate_interp_funcs_ext('Dbg')]
3767
3768 return "\n".join(body)
3769
3770class GlaveReplayHeader(Subcommand):
3771 def generate_header(self):
3772 header_txt = []
3773 header_txt.append('#pragma once\n')
3774 header_txt.append('#include <set>')
3775 header_txt.append('#include <map>')
3776 header_txt.append('#include <vector>')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]3777 header_txt.append('#include <string>')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3778 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3779 header_txt.append('#include <xcb/xcb.h>\n')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]3780 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3781 header_txt.append('#include "glvreplay_window.h"')
3782 header_txt.append('#include "glvreplay_factory.h"')
3783 header_txt.append('#include "glv_trace_packet_identifiers.h"\n')
3784 header_txt.append('#include "xgl.h"')
3785 header_txt.append('#include "xglDbg.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]3786 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3787 header_txt.append('#include "xglWsiX11Ext.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]3788 header_txt.append('#else')
3789 header_txt.append('#include "xglWsiWinExt.h"')
3790 header_txt.append('#endif')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]3791 header_txt.append('#include "draw_state.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3792 return "\n".join(header_txt)
3793
3794 def generate_body(self):
3795 body = [self._generate_replay_class_decls(),
3796 self._generate_replay_func_ptrs(),
3797 self._generate_replay_class()]
3798
3799 return "\n".join(body)
3800
3801class GlaveReplayC(Subcommand):
3802 def generate_header(self):
3803 header_txt = []
3804 header_txt.append('#include "glvreplay_xgl_replay.h"\n')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]3805 header_txt.append('#include "glvreplay_xgl.h"\n')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]3806 header_txt.append('#include "glvreplay_xgl_write_ppm.h"\n')
3807 header_txt.append('#include "glvreplay_main.h"\n')
3808 header_txt.append('#include <algorithm>')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]3809 header_txt.append('#include <queue>')
Ian Elliott91e681e2015-02-18 15:35:00 -0700[diff] [blame]3810 header_txt.append('glvreplay_settings *g_pReplaySettings;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3811 header_txt.append('extern "C" {')
3812 header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
3813 header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
3814 header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
3815 header_txt.append('#include "glvtrace_xgl_packet_id.h"')
3816 header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')
3817 header_txt.append('#define APP_NAME "glvreplay_xgl"')
3818 header_txt.append('#define IDI_ICON 101\n')
3819 header_txt.append('static const char* g_extensions[] =')
3820 header_txt.append('{')
3821 header_txt.append(' "XGL_WSI_WINDOWS",')
3822 header_txt.append(' "XGL_TIMER_QUEUE",')
3823 header_txt.append(' "XGL_GPU_TIMESTAMP_CALIBRATION",')
3824 header_txt.append(' "XGL_DMA_QUEUE",')
3825 header_txt.append(' "XGL_COMMAND_BUFFER_CONTROL_FLOW",')
3826 header_txt.append(' "XGL_COPY_OCCLUSION_QUERY_DATA",')
3827 header_txt.append(' "XGL_ADVANCED_MULTISAMPLING",')
3828 header_txt.append(' "XGL_BORDER_COLOR_PALETTE"')
3829 header_txt.append('};')
3830 return "\n".join(header_txt)
3831
3832 def generate_body(self):
3833 body = [self._generate_replay_display_init_xgl(),
3834 self._generate_replay_display_init(),
3835 self._generate_replay_display_structors(),
3836 self._generate_replay_display_window(),
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]3837 self._generate_replay_objMemory_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3838 self._generate_replay_structors(),
3839 self._generate_replay_init(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3840 self._generate_replay_errors(),
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]3841 self._generate_replay_validation_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3842 self._generate_replay_init_funcs(),
3843 self._generate_replay()]
3844
3845 return "\n".join(body)
3846
3847def main():
3848 subcommands = {
3849 "glave-trace-h" : GlaveTraceHeader,
3850 "glave-trace-c" : GlaveTraceC,
3851 "glave-packet-id" : GlavePacketID,
3852 "glave-core-structs" : GlaveCoreStructs,
3853 "glave-wsi-trace-h" : GlaveWsiHeader,
3854 "glave-wsi-trace-c" : GlaveWsiC,
3855 "glave-wsi-trace-structs" : GlaveWsiStructs,
3856 "glave-dbg-trace-h" : GlaveDbgHeader,
3857 "glave-dbg-trace-c" : GlaveDbgC,
3858 "glave-dbg-trace-structs" : GlaveDbgStructs,
3859 "glave-replay-h" : GlaveReplayHeader,
3860 "glave-replay-c" : GlaveReplayC,
3861 }
3862
3863 if len(sys.argv) < 2 or sys.argv[1] not in subcommands:
3864 print("Usage: %s <subcommand> [options]" % sys.argv[0])
3865 print
3866 print("Available sucommands are: %s" % " ".join(subcommands))
3867 exit(1)
3868
3869 subcmd = subcommands[sys.argv[1]](sys.argv[2:])
3870 subcmd.run()
3871
3872if __name__ == "__main__":
3873 main()