Merge branch 'ppc-fix'

Author: planrich

jitlog/__main__.py

@@ -3,7 +3,7 @@
 import tempfile
 import argparse
 from jitlog.upload import upload as jitlog_upload
-from vmprofservice import get_url
+from vmshare import get_url
 from jitlog.parser import parse_jitlog
 
 try:
@@ -27,6 +27,14 @@ def build_argparser():
         help='program arguments'
     )
 
+    parser.add_argument('--query', '-q', dest='query',
+        help='Select traces and pretty print them. ' \
+             'Example: -i <file> -q "\'my_func\' in name" ' \
+             'The query API can be found on https://vmprof.readthedocs.org'
+    )
+    parser.add_argument('--input', '-i', dest='input',
+        help='Specify the file to read from. Use with in combination with --query'
+    )
     parser.add_argument(
         '--web-auth',
         help='Authtoken for your acount on the server, works only when --web is used'
@@ -63,6 +71,14 @@ def main():
     args = parser.parse_args(sys.argv[1:])
     web = args.web
 
+    if args.input:
+        assert args.query is not None, "Using -i requires you to specify -q"
+        forest = parse_jitlog(args.input)
+        q = query.new_unsafe_query(args.query)
+        objs = q(forest)
+        pretty_printer.write(sys.stdout, objs)
+        sys.exit(0)
+
     if args.upload:
         # parse_jitlog will append source code to the binary
         forest = parse_jitlog(args.program)

jitlog/marks.py

@@ -2,36 +2,32 @@
 from jitlog import constants as const
 from jitlog import merge_point
 from jitlog.objects import FlatOp, MergePoint
-from vmprof.binary import (read_word, read_string,
+from vmshare.binary import (read_word, read_string,
         read_le_u16, read_le_u64,
         read_le_s64, read_bytes, read_byte,
         read_char)
 import base64
 import sys
 import re
 
-VERSIONS = {}
+PARSERS = {}
 
 def get_reader(version, mark):
-    return VERSIONS[version][mark]
+    return PARSERS[mark]
 
-def version(*versions):
+def mark_parser(*versions):
     def func(parser):
-        for ver in versions:
-            if ver not in VERSIONS:
-                VERSIONS[ver] = {}
-            parsers = VERSIONS[ver]
-            #
-            name = parser.__name__
-            assert name.startswith("read_")
-            name = "MARK_" + name[5:].upper()
-            mark = getattr(const, name, -1)
-            assert mark not in parsers, "%s for version %d has already been defined" % (parser.__name__, ver)
-            parsers[mark] = parser
+        # the versions are irrelevant for now
+        name = parser.__name__
+        assert name.startswith("read_")
+        name = "MARK_" + name[5:].upper()
+        mark = getattr(const, name, -1)
+        assert mark not in PARSERS, "%s has already been defined" % (parser.__name__)
+        PARSERS[mark] = parser
         return parser
     return func
 
-@version(1)
+@mark_parser(1)
 def read_resop_meta(forest, trace, fileobj):
     assert len(forest.resops) == 0
     count = read_le_u16(fileobj)
@@ -40,87 +36,108 @@ def read_resop_meta(forest, trace, fileobj):
         opname = read_string(fileobj, True)
         forest.resops[opnum] = opname
 
-@version(1)
+@mark_parser(
+     1,
+    (2, "encode jitdriver name after trace_nmr")
+)
 def read_start_trace(forest, trace, fileobj):
     trace_id = forest.read_le_addr(fileobj)
     trace_type = read_string(fileobj, True)
     trace_nmr = forest.read_le_addr(fileobj)
+    # version 2 adds the jitdriver name
+    if forest.version >= 2:
+        jitdriver_name = read_string(fileobj, True)
+    else:
+        jitdriver_name = None
     #
     assert trace_id not in forest.traces
-    forest.add_trace(trace_type, trace_id, trace_nmr)
+    forest.add_trace(trace_type, trace_id, trace_nmr, jitdriver_name)
 
-@version(1)
+@mark_parser(1)
 def read_trace(forest, trace, fileobj):
     assert trace is not None
     trace_id = forest.read_le_addr(fileobj)
     assert trace_id == trace.unique_id
     trace.start_mark(const.MARK_TRACE)
 
-@version(1)
+@mark_parser(1)
 def read_trace_opt(forest, trace, fileobj):
     assert trace is not None
     trace_id = forest.read_le_addr(fileobj)
     assert trace_id == trace.unique_id
     trace.start_mark(const.MARK_TRACE_OPT)
 
-@version(1)
+@mark_parser(1)
 def read_trace_asm(forest, trace, fileobj):
     assert trace is not None
     trace_id = forest.read_le_addr(fileobj)
     assert trace_id == trace.unique_id
     trace.start_mark(const.MARK_TRACE_ASM)
 
-@version(1)
+@mark_parser(1)
 def read_input_args(forest, trace, fileobj):
     assert trace is not None
     argnames = read_string(fileobj, True).split(',')
     trace.set_inputargs(argnames)
 
-@version(1)
+@mark_parser(
+    1,
+    (2, "encodes guard failure arguments"),
+)
 def read_resop(forest, trace, fileobj):
     assert trace is not None
     opnum = read_le_u16(fileobj)
     args = read_string(fileobj, True).split(',')
+    failargs = None
+    if 2 <= forest.version:
+        failargs = read_string(fileobj, True).split(',')
     result = args[0]
     args = args[1:]
     assert opnum in forest.resops, "opnum is not known: " + str(opnum) + \
                   " at binary pos " + str(hex(fileobj.tell()))
     opname = forest.resops[opnum]
-    op = FlatOp(opnum, opname, args, result, None, -1)
+
+    op = FlatOp(opnum, opname, args, result, None, -1, failargs=failargs)
     trace.add_instr(op)
 
 TOKEN_REGEX = re.compile("TargetToken\((\d+)\)")
 
-@version(1)
+@mark_parser(
+    1,
+    (2, "encodes guard failure arguments"),
+)
 def read_resop_descr(forest, trace, fileobj):
     assert trace is not None
     opnum = read_le_u16(fileobj)
     args = read_string(fileobj, True).split(',')
     descr_number = forest.read_le_addr(fileobj)
+    failargs = None
+    if 2 <= forest.version:
+        failargs = read_string(fileobj, True).split(',')
     descr = args[-1]
     result = args[0]
     args = args[1:-1]
     assert opnum in forest.resops, "opnum is not known: " + str(opnum) + \
                   " at binary pos " + str(hex(fileobj.tell()))
     opname = forest.resops[opnum]
-    op = FlatOp(opnum, opname, args, result, descr, descr_number)
+    op = FlatOp(opnum, opname, args, result, descr, descr_number, failargs=failargs)
     trace.add_instr(op)
 
-@version(1)
+@mark_parser(1)
 def read_asm_addr(forest, trace, fileobj):
     assert trace is not None
     addr1 = forest.read_le_addr(fileobj)
     addr2 = forest.read_le_addr(fileobj)
     trace.set_addr_bounds(addr1, addr2)
 
-@version(1)
+@mark_parser(1)
 def read_asm(forest, trace, fileobj):
     assert trace is not None
     rel_pos = read_le_u16(fileobj)
     dump = read_bytes(fileobj)
     trace.set_core_dump_to_last_op(rel_pos, dump)
 
-@version(1)
+@mark_parser(1)
 def read_init_merge_point(forest, trace, fileobj):
     count = read_le_u16(fileobj)
     types = []
@@ -133,14 +150,14 @@ def read_init_merge_point(forest, trace, fileobj):
     assert stage is not None
     stage.merge_point_types = types
 
-@version(1)
+@mark_parser(1)
 def read_common_prefix(forest, trace, fileobj):
     index = ord(fileobj.read(1))
     prefix = read_string(fileobj, True)
     stage = trace.get_last_stage()
     stage.merge_point_types[index].set_prefix(prefix)
 
-@version(1)
+@mark_parser(1)
 def read_merge_point(forest, trace, fileobj):
     assert trace is not None
     stage = trace.get_last_stage()
@@ -150,13 +167,13 @@ def read_merge_point(forest, trace, fileobj):
                for decoder in stage.merge_point_types }
     trace.add_instr(MergePoint(values))
 
-@version(1)
+@mark_parser(1)
 def read_stitch_bridge(forest, trace, fileobj):
     descr_number = forest.read_le_addr(fileobj)
     addr_tgt = forest.read_le_addr(fileobj)
     forest.stitch_bridge(descr_number, addr_tgt)
 
-@version(1)
+@mark_parser(1)
 def read_jitlog_counter(forest, trace, fileobj):
     addr = forest.read_le_addr(fileobj)
     type = read_char(fileobj)
@@ -187,12 +204,12 @@ def read_jitlog_counter(forest, trace, fileobj):
           " but was not recorded in the log\n" % (addr, type, count))
     return False
 
-@version(1)
+@mark_parser(1)
 def read_abort_trace(forest, trace, fileobj):
     trace_id = forest.read_le_addr(fileobj)
     # TODO?
 
-@version(1)
+@mark_parser(1)
 def read_source_code(forest, trace, fileobj):
     filename = read_string(fileobj, True)
     count = read_le_u16(fileobj)

jitlog/merge_point.py

@@ -1,5 +1,5 @@
 from jitlog import constants as const
-from vmprof.binary import read_string, read_le_u64
+from vmshare.binary import read_string, read_le_u64
 
 class MergePointDecoder(object):
     def __init__(self, sem_type):
@@ -28,7 +28,6 @@ def decode(self, fileobj):
 
 def get_decoder(sem_type, gen_type, version):
     assert 0 <= sem_type <= const.MP_OPCODE[0]
-    assert version == 1
     if gen_type == "s":
         return StrMergePointDecoder(sem_type)
     else: