| #!/usr/bin/env python3 |
| ########################################################################## |
| # |
| # Copyright 2008 VMware, Inc. |
| # All Rights Reserved. |
| # |
| # Permission is hereby granted, free of charge, to any person obtaining a |
| # copy of this software and associated documentation files (the |
| # "Software"), to deal in the Software without restriction, including |
| # without limitation the rights to use, copy, modify, merge, publish, |
| # distribute, sub license, and/or sell copies of the Software, and to |
| # permit persons to whom the Software is furnished to do so, subject to |
| # the following conditions: |
| # |
| # The above copyright notice and this permission notice (including the |
| # next paragraph) shall be included in all copies or substantial portions |
| # of the Software. |
| # |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
| # IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR |
| # ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| # |
| ########################################################################## |
| |
| |
| import io |
| import sys |
| import xml.parsers.expat as xpat |
| import argparse |
| |
| import format |
| from model import * |
| |
| |
| trace_ignore_calls = set(( |
| ("pipe_screen", "is_format_supported"), |
| ("pipe_screen", "get_name"), |
| ("pipe_screen", "get_vendor"), |
| ("pipe_screen", "get_param"), |
| ("pipe_screen", "get_paramf"), |
| ("pipe_screen", "get_shader_param"), |
| ("pipe_screen", "get_compute_param"), |
| ("pipe_screen", "get_disk_shader_cache"), |
| )) |
| |
| |
| def trace_call_ignore(call): |
| return (call.klass, call.method) in trace_ignore_calls |
| |
| |
| ELEMENT_START, ELEMENT_END, CHARACTER_DATA, EOF = range(4) |
| |
| |
| class XmlToken: |
| |
| def __init__(self, type, name_or_data, attrs = None, line = None, column = None): |
| assert type in (ELEMENT_START, ELEMENT_END, CHARACTER_DATA, EOF) |
| self.type = type |
| self.name_or_data = name_or_data |
| self.attrs = attrs |
| self.line = line |
| self.column = column |
| |
| def __str__(self): |
| if self.type == ELEMENT_START: |
| return '<' + self.name_or_data + ' ...>' |
| if self.type == ELEMENT_END: |
| return '</' + self.name_or_data + '>' |
| if self.type == CHARACTER_DATA: |
| return self.name_or_data |
| if self.type == EOF: |
| return 'end of file' |
| assert 0 |
| |
| |
| class XmlTokenizer: |
| """Expat based XML tokenizer.""" |
| |
| def __init__(self, fp, skip_ws = True): |
| self.fp = fp |
| self.tokens = [] |
| self.index = 0 |
| self.final = False |
| self.skip_ws = skip_ws |
| |
| self.character_pos = 0, 0 |
| self.character_data = [] |
| |
| self.parser = xpat.ParserCreate() |
| self.parser.StartElementHandler = self.handle_element_start |
| self.parser.EndElementHandler = self.handle_element_end |
| self.parser.CharacterDataHandler = self.handle_character_data |
| |
| def handle_element_start(self, name, attributes): |
| self.finish_character_data() |
| line, column = self.pos() |
| token = XmlToken(ELEMENT_START, name, attributes, line, column) |
| self.tokens.append(token) |
| |
| def handle_element_end(self, name): |
| self.finish_character_data() |
| line, column = self.pos() |
| token = XmlToken(ELEMENT_END, name, None, line, column) |
| self.tokens.append(token) |
| |
| def handle_character_data(self, data): |
| if not self.character_data: |
| self.character_pos = self.pos() |
| self.character_data.append(data) |
| |
| def finish_character_data(self): |
| if self.character_data: |
| character_data = ''.join(self.character_data) |
| if not self.skip_ws or not character_data.isspace(): |
| line, column = self.character_pos |
| token = XmlToken(CHARACTER_DATA, character_data, None, line, column) |
| self.tokens.append(token) |
| self.character_data = [] |
| |
| def next(self): |
| size = 16*1024 |
| while self.index >= len(self.tokens) and not self.final: |
| self.tokens = [] |
| self.index = 0 |
| data = self.fp.read(size) |
| self.final = len(data) < size |
| data = data.rstrip('\0') |
| try: |
| self.parser.Parse(data, self.final) |
| except xpat.ExpatError as e: |
| #if e.code == xpat.errors.XML_ERROR_NO_ELEMENTS: |
| if e.code == 3: |
| pass |
| else: |
| raise e |
| if self.index >= len(self.tokens): |
| line, column = self.pos() |
| token = XmlToken(EOF, None, None, line, column) |
| else: |
| token = self.tokens[self.index] |
| self.index += 1 |
| return token |
| |
| def pos(self): |
| return self.parser.CurrentLineNumber, self.parser.CurrentColumnNumber |
| |
| |
| class TokenMismatch(Exception): |
| |
| def __init__(self, expected, found): |
| self.expected = expected |
| self.found = found |
| |
| def __str__(self): |
| return '%u:%u: %s expected, %s found' % (self.found.line, self.found.column, str(self.expected), str(self.found)) |
| |
| |
| |
| class XmlParser: |
| """Base XML document parser.""" |
| |
| def __init__(self, fp): |
| self.tokenizer = XmlTokenizer(fp) |
| self.consume() |
| |
| def consume(self): |
| self.token = self.tokenizer.next() |
| |
| def match_element_start(self, name): |
| return self.token.type == ELEMENT_START and self.token.name_or_data == name |
| |
| def match_element_end(self, name): |
| return self.token.type == ELEMENT_END and self.token.name_or_data == name |
| |
| def element_start(self, name): |
| while self.token.type == CHARACTER_DATA: |
| self.consume() |
| if self.token.type != ELEMENT_START: |
| raise TokenMismatch(XmlToken(ELEMENT_START, name), self.token) |
| if self.token.name_or_data != name: |
| raise TokenMismatch(XmlToken(ELEMENT_START, name), self.token) |
| attrs = self.token.attrs |
| self.consume() |
| return attrs |
| |
| def element_end(self, name): |
| while self.token.type == CHARACTER_DATA: |
| self.consume() |
| if self.token.type != ELEMENT_END: |
| raise TokenMismatch(XmlToken(ELEMENT_END, name), self.token) |
| if self.token.name_or_data != name: |
| raise TokenMismatch(XmlToken(ELEMENT_END, name), self.token) |
| self.consume() |
| |
| def character_data(self, strip = True): |
| data = '' |
| while self.token.type == CHARACTER_DATA: |
| data += self.token.name_or_data |
| self.consume() |
| if strip: |
| data = data.strip() |
| return data |
| |
| |
| class TraceParser(XmlParser): |
| |
| def __init__(self, fp, options, state): |
| XmlParser.__init__(self, fp) |
| self.last_call_no = 0 |
| self.state = state |
| self.options = options |
| |
| def parse(self): |
| self.element_start('trace') |
| while self.token.type not in (ELEMENT_END, EOF): |
| call = self.parse_call() |
| call.is_junk = trace_call_ignore(call) |
| self.handle_call(call) |
| if self.token.type != EOF: |
| self.element_end('trace') |
| |
| def parse_call(self): |
| attrs = self.element_start('call') |
| try: |
| no = int(attrs['no']) |
| except KeyError as e: |
| self.last_call_no += 1 |
| no = self.last_call_no |
| else: |
| self.last_call_no = no |
| klass = attrs['class'] |
| method = attrs['method'] |
| args = [] |
| ret = None |
| time = None |
| while self.token.type == ELEMENT_START: |
| if self.token.name_or_data == 'arg': |
| arg = self.parse_arg() |
| args.append(arg) |
| elif self.token.name_or_data == 'ret': |
| ret = self.parse_ret() |
| elif self.token.name_or_data == 'call': |
| # ignore nested function calls |
| self.parse_call() |
| elif self.token.name_or_data == 'time': |
| time = self.parse_time() |
| else: |
| raise TokenMismatch("<arg ...> or <ret ...>", self.token) |
| self.element_end('call') |
| |
| return Call(no, klass, method, args, ret, time) |
| |
| def parse_arg(self): |
| attrs = self.element_start('arg') |
| name = attrs['name'] |
| value = self.parse_value(name) |
| self.element_end('arg') |
| |
| return name, value |
| |
| def parse_ret(self): |
| attrs = self.element_start('ret') |
| value = self.parse_value('ret') |
| self.element_end('ret') |
| |
| return value |
| |
| def parse_time(self): |
| attrs = self.element_start('time') |
| time = self.parse_value('time'); |
| self.element_end('time') |
| return time |
| |
| def parse_value(self, name): |
| expected_tokens = ('null', 'bool', 'int', 'uint', 'float', 'string', 'enum', 'array', 'struct', 'ptr', 'bytes') |
| if self.token.type == ELEMENT_START: |
| if self.token.name_or_data in expected_tokens: |
| method = getattr(self, 'parse_' + self.token.name_or_data) |
| return method(name) |
| raise TokenMismatch(" or " .join(expected_tokens), self.token) |
| |
| def parse_null(self, pname): |
| self.element_start('null') |
| self.element_end('null') |
| return Literal(None) |
| |
| def parse_bool(self, pname): |
| self.element_start('bool') |
| value = int(self.character_data()) |
| self.element_end('bool') |
| return Literal(value) |
| |
| def parse_int(self, pname): |
| self.element_start('int') |
| value = int(self.character_data()) |
| self.element_end('int') |
| return Literal(value) |
| |
| def parse_uint(self, pname): |
| self.element_start('uint') |
| value = int(self.character_data()) |
| self.element_end('uint') |
| return Literal(value) |
| |
| def parse_float(self, pname): |
| self.element_start('float') |
| value = float(self.character_data()) |
| self.element_end('float') |
| return Literal(value) |
| |
| def parse_enum(self, pname): |
| self.element_start('enum') |
| name = self.character_data() |
| self.element_end('enum') |
| return NamedConstant(name) |
| |
| def parse_string(self, pname): |
| self.element_start('string') |
| value = self.character_data() |
| self.element_end('string') |
| return Literal(value) |
| |
| def parse_bytes(self, pname): |
| self.element_start('bytes') |
| value = self.character_data() |
| self.element_end('bytes') |
| return Blob(value) |
| |
| def parse_array(self, pname): |
| self.element_start('array') |
| elems = [] |
| while self.token.type != ELEMENT_END: |
| elems.append(self.parse_elem('array')) |
| self.element_end('array') |
| return Array(elems) |
| |
| def parse_elem(self, pname): |
| self.element_start('elem') |
| value = self.parse_value('elem') |
| self.element_end('elem') |
| return value |
| |
| def parse_struct(self, pname): |
| attrs = self.element_start('struct') |
| name = attrs['name'] |
| members = [] |
| while self.token.type != ELEMENT_END: |
| members.append(self.parse_member(name)) |
| self.element_end('struct') |
| return Struct(name, members) |
| |
| def parse_member(self, pname): |
| attrs = self.element_start('member') |
| name = attrs['name'] |
| value = self.parse_value(name) |
| self.element_end('member') |
| |
| return name, value |
| |
| def parse_ptr(self, pname): |
| self.element_start('ptr') |
| address = self.character_data() |
| self.element_end('ptr') |
| |
| return Pointer(self.state, address, pname) |
| |
| def handle_call(self, call): |
| pass |
| |
| |
| class SimpleTraceDumper(TraceParser): |
| |
| def __init__(self, fp, options, formatter, state): |
| TraceParser.__init__(self, fp, options, state) |
| self.options = options |
| self.formatter = formatter |
| self.pretty_printer = PrettyPrinter(self.formatter, options) |
| |
| def handle_call(self, call): |
| if self.options.ignore_junk and call.is_junk: |
| return |
| |
| call.visit(self.pretty_printer) |
| |
| |
| class TraceDumper(SimpleTraceDumper): |
| |
| def __init__(self, fp, options, formatter, state): |
| SimpleTraceDumper.__init__(self, fp, options, formatter, state) |
| self.call_stack = [] |
| |
| def handle_call(self, call): |
| if self.options.ignore_junk and call.is_junk: |
| return |
| |
| if self.options.named_ptrs: |
| self.call_stack.append(call) |
| else: |
| call.visit(self.pretty_printer) |
| |
| |
| class ParseOptions(ModelOptions): |
| |
| def __init__(self, args=None): |
| # Initialize options local to this module |
| self.plain = False |
| self.ignore_junk = False |
| |
| ModelOptions.__init__(self, args) |
| |
| |
| class Main: |
| '''Common main class for all retrace command line utilities.''' |
| |
| def __init__(self): |
| pass |
| |
| def main(self): |
| optparser = self.get_optparser() |
| args = optparser.parse_args() |
| options = self.make_options(args) |
| |
| for fname in args.filename: |
| try: |
| if fname.endswith('.gz'): |
| from gzip import GzipFile |
| stream = io.TextIOWrapper(GzipFile(fname, 'rb')) |
| elif fname.endswith('.bz2'): |
| from bz2 import BZ2File |
| stream = io.TextIOWrapper(BZ2File(fname, 'rb')) |
| else: |
| stream = open(fname, 'rt') |
| except Exception as e: |
| print("ERROR: {}".format(str(e))) |
| sys.exit(1) |
| |
| self.process_arg(stream, options) |
| |
| def make_options(self, args): |
| return ParseOptions(args) |
| |
| def get_optparser(self): |
| estr = "\nList of junk calls:\n" |
| for klass, call in sorted(trace_ignore_calls): |
| estr += f" {klass}::{call}\n" |
| |
| optparser = argparse.ArgumentParser( |
| description="Parse and dump Gallium trace(s)", |
| formatter_class=argparse.RawDescriptionHelpFormatter, |
| epilog=estr) |
| |
| optparser.add_argument("filename", action="extend", nargs="+", |
| type=str, metavar="filename", help="Gallium trace filename (plain or .gz, .bz2)") |
| |
| optparser.add_argument("-p", "--plain", |
| action="store_const", const=True, default=False, |
| dest="plain", help="disable ANSI color etc. formatting") |
| |
| optparser.add_argument("-S", "--suppress", |
| action="store_const", const=True, default=False, |
| dest="suppress_variants", help="suppress some variants in output for better diffability") |
| |
| optparser.add_argument("-N", "--named", |
| action="store_const", const=True, default=False, |
| dest="named_ptrs", help="generate symbolic names for raw pointer values") |
| |
| optparser.add_argument("-M", "--method-only", |
| action="store_const", const=True, default=False, |
| dest="method_only", help="output only call names without arguments") |
| |
| optparser.add_argument("-I", "--ignore-junk", |
| action="store_const", const=True, default=False, |
| dest="ignore_junk", help="filter out/ignore junk calls (see below)") |
| |
| return optparser |
| |
| def process_arg(self, stream, options): |
| if options.plain: |
| formatter = format.Formatter(sys.stdout) |
| else: |
| formatter = format.DefaultFormatter(sys.stdout) |
| |
| dump = TraceDumper(stream, options, formatter, TraceStateData()) |
| dump.parse() |
| |
| if options.named_ptrs: |
| for call in dump.call_stack: |
| call.visit(dump.pretty_printer) |
| |
| |
| if __name__ == '__main__': |
| Main().main() |
