Author: Antonio Cuni <[email protected]>
Branch:
Changeset: r44867:4c1c8d063e19
Date: 2011-06-09 13:38 +0200
http://bitbucket.org/pypy/pypy/changeset/4c1c8d063e19/
Log: merge the oparser-mock-model branch; now the jitlogparser uses a
mock model for representing loops, boxes, etc.. This makes the
jitviewer startup time much faster
diff --git a/pypy/jit/metainterp/history.py b/pypy/jit/metainterp/history.py
--- a/pypy/jit/metainterp/history.py
+++ b/pypy/jit/metainterp/history.py
@@ -1063,6 +1063,8 @@
Explodes if the annotator only thinks it is an instance of AbstractValue.
"""
if x is not None:
+ if not we_are_translated() and getattr(x, 'I_am_a_descr', False):
+ return # needed for the mock case in oparser_model
assert isinstance(x, AbstractDescr)
class Entry(ExtRegistryEntry):
diff --git a/pypy/jit/tool/oparser.py b/pypy/jit/tool/oparser.py
--- a/pypy/jit/tool/oparser.py
+++ b/pypy/jit/tool/oparser.py
@@ -3,24 +3,15 @@
in a nicer fashion
"""
-from pypy.jit.metainterp.history import TreeLoop, BoxInt, ConstInt,\
- ConstObj, ConstPtr, Box, BasicFailDescr, BoxFloat, ConstFloat,\
- LoopToken, get_const_ptr_for_string, get_const_ptr_for_unicode
+from pypy.jit.tool.oparser_model import get_model
+
from pypy.jit.metainterp.resoperation import rop, ResOperation, \
ResOpWithDescr, N_aryOp, \
UnaryOp, PlainResOp
-from pypy.jit.metainterp.typesystem import llhelper
-from pypy.jit.codewriter.heaptracker import adr2int
-from pypy.jit.codewriter import longlong
-from pypy.rpython.lltypesystem import lltype, llmemory
-from pypy.rpython.ootypesystem import ootype
class ParseError(Exception):
pass
-class Boxes(object):
- pass
-
class ESCAPE_OP(N_aryOp, ResOpWithDescr):
OPNUM = -123
@@ -54,37 +45,16 @@
def clone(self):
return FORCE_SPILL(self.OPNUM, self.getarglist()[:])
-class ExtendedTreeLoop(TreeLoop):
-
- def getboxes(self):
- def opboxes(operations):
- for op in operations:
- yield op.result
- for box in op.getarglist():
- yield box
- def allboxes():
- for box in self.inputargs:
- yield box
- for box in opboxes(self.operations):
- yield box
-
- boxes = Boxes()
- for box in allboxes():
- if isinstance(box, Box):
- name = str(box)
- setattr(boxes, name, box)
- return boxes
-
- def setvalues(self, **kwds):
- boxes = self.getboxes()
- for name, value in kwds.iteritems():
- getattr(boxes, name).value = value
def default_fail_descr(fail_args=None):
+ from pypy.jit.metainterp.history import BasicFailDescr
return BasicFailDescr()
class OpParser(object):
+
+ use_mock_model = False
+
def __init__(self, input, cpu, namespace, type_system, boxkinds,
invent_fail_descr=default_fail_descr,
nonstrict=False):
@@ -100,7 +70,8 @@
self._cache = {}
self.invent_fail_descr = invent_fail_descr
self.nonstrict = nonstrict
- self.looptoken = LoopToken()
+ self.model = get_model(self.use_mock_model)
+ self.looptoken = self.model.LoopToken()
def get_const(self, name, typ):
if self._consts is None:
@@ -108,16 +79,16 @@
obj = self._consts[name]
if self.type_system == 'lltype':
if typ == 'ptr':
- return ConstPtr(obj)
+ return self.model.ConstPtr(obj)
else:
assert typ == 'class'
- return ConstInt(adr2int(llmemory.cast_ptr_to_adr(obj)))
+ return self.model.ConstInt(self.model.ptr_to_int(obj))
else:
if typ == 'ptr':
- return ConstObj(obj)
+ return self.model.ConstObj(obj)
else:
assert typ == 'class'
- return ConstObj(ootype.cast_to_object(obj))
+ return self.model.ConstObj(ootype.cast_to_object(obj))
def get_descr(self, poss_descr):
if poss_descr.startswith('<'):
@@ -132,16 +103,16 @@
pass
if elem.startswith('i'):
# integer
- box = BoxInt()
- _box_counter_more_than(elem[1:])
+ box = self.model.BoxInt()
+ _box_counter_more_than(self.model, elem[1:])
elif elem.startswith('f'):
- box = BoxFloat()
- _box_counter_more_than(elem[1:])
+ box = self.model.BoxFloat()
+ _box_counter_more_than(self.model, elem[1:])
elif elem.startswith('p'):
# pointer
- ts = getattr(self.cpu, 'ts', llhelper)
+ ts = getattr(self.cpu, 'ts', self.model.llhelper)
box = ts.BoxRef()
- _box_counter_more_than(elem[1:])
+ _box_counter_more_than(self.model, elem[1:])
else:
for prefix, boxclass in self.boxkinds.iteritems():
if elem.startswith(prefix):
@@ -175,21 +146,21 @@
def getvar(self, arg):
if not arg:
- return ConstInt(0)
+ return self.model.ConstInt(0)
try:
- return ConstInt(int(arg))
+ return self.model.ConstInt(int(arg))
except ValueError:
if self.is_float(arg):
- return ConstFloat(longlong.getfloatstorage(float(arg)))
+ return
self.model.ConstFloat(self.model.convert_to_floatstorage(arg))
if (arg.startswith('"') or arg.startswith("'") or
arg.startswith('s"')):
# XXX ootype
info = arg[1:].strip("'\"")
- return get_const_ptr_for_string(info)
+ return self.model.get_const_ptr_for_string(info)
if arg.startswith('u"'):
# XXX ootype
info = arg[1:].strip("'\"")
- return get_const_ptr_for_unicode(info)
+ return self.model.get_const_ptr_for_unicode(info)
if arg.startswith('ConstClass('):
name = arg[len('ConstClass('):-1]
return self.get_const(name, 'class')
@@ -197,9 +168,9 @@
return None
elif arg == 'NULL':
if self.type_system == 'lltype':
- return ConstPtr(ConstPtr.value)
+ return self.model.ConstPtr(self.model.ConstPtr.value)
else:
- return ConstObj(ConstObj.value)
+ return self.model.ConstObj(self.model.ConstObj.value)
elif arg.startswith('ConstPtr('):
name = arg[len('ConstPtr('):-1]
return self.get_const(name, 'ptr')
@@ -338,7 +309,7 @@
num, ops, last_offset = self.parse_ops(base_indent, newlines, 0)
if num < len(newlines):
raise ParseError("unexpected dedent at line: %s" % newlines[num])
- loop = ExtendedTreeLoop("loop")
+ loop = self.model.ExtendedTreeLoop("loop")
loop.comment = first_comment
loop.token = self.looptoken
loop.operations = ops
@@ -394,7 +365,7 @@
def parse(input, cpu=None, namespace=None, type_system='lltype',
boxkinds=None, invent_fail_descr=default_fail_descr,
- no_namespace=False, nonstrict=False):
+ no_namespace=False, nonstrict=False, OpParser=OpParser):
if namespace is None and not no_namespace:
namespace = {}
return OpParser(input, cpu, namespace, type_system, boxkinds,
@@ -405,6 +376,6 @@
return parse(*args, **kwds)
-def _box_counter_more_than(s):
+def _box_counter_more_than(model, s):
if s.isdigit():
- Box._counter = max(Box._counter, int(s)+1)
+ model.Box._counter = max(model.Box._counter, int(s)+1)
diff --git a/pypy/jit/tool/oparser_model.py b/pypy/jit/tool/oparser_model.py
new file mode 100644
--- /dev/null
+++ b/pypy/jit/tool/oparser_model.py
@@ -0,0 +1,144 @@
+class Boxes(object):
+ pass
+
+def get_real_model():
+ class LoopModel(object):
+ from pypy.jit.metainterp.history import TreeLoop, LoopToken
+ from pypy.jit.metainterp.history import Box, BoxInt, BoxFloat
+ from pypy.jit.metainterp.history import ConstInt, ConstObj, ConstPtr,
ConstFloat
+ from pypy.jit.metainterp.typesystem import llhelper
+
+ from pypy.jit.metainterp.history import get_const_ptr_for_string
+ from pypy.jit.metainterp.history import get_const_ptr_for_unicode
+ get_const_ptr_for_string = staticmethod(get_const_ptr_for_string)
+ get_const_ptr_for_unicode = staticmethod(get_const_ptr_for_unicode)
+
+ @staticmethod
+ def convert_to_floatstorage(arg):
+ from pypy.jit.codewriter import longlong
+ return longlong.getfloatstorage(float(arg))
+
+ @staticmethod
+ def ptr_to_int(obj):
+ from pypy.jit.codewriter.heaptracker import adr2int
+ from pypy.rpython.lltypesystem import llmemory
+ return adr2int(llmemory.cast_ptr_to_adr(obj))
+
+ @staticmethod
+ def ootype_cast_to_object(obj):
+ from pypy.rpython.ootypesystem import ootype
+ return ootype.cast_to_object(obj)
+
+ return LoopModel
+
+def get_mock_model():
+ class LoopModel(object):
+
+ class TreeLoop(object):
+ def __init__(self, name):
+ self.name = name
+
+ class LoopToken(object):
+ I_am_a_descr = True
+
+ class Box(object):
+ _counter = 0
+ type = 'b'
+
+ def __init__(self, value=0):
+ self.value = value
+
+ def __repr__(self):
+ result = str(self)
+ result += '(%s)' % self.value
+ return result
+
+ def __str__(self):
+ if not hasattr(self, '_str'):
+ self._str = '%s%d' % (self.type, Box._counter)
+ Box._counter += 1
+ return self._str
+
+ class BoxInt(Box):
+ type = 'i'
+
+ class BoxFloat(Box):
+ type = 'f'
+
+ class BoxRef(Box):
+ type = 'p'
+
+ class Const(object):
+ def __init__(self, value=None):
+ self.value = value
+
+ def _get_str(self):
+ return str(self.value)
+
+ class ConstInt(Const):
+ pass
+
+ class ConstPtr(Const):
+ pass
+
+ class ConstFloat(Const):
+ pass
+
+ @classmethod
+ def get_const_ptr_for_string(cls, s):
+ return cls.ConstPtr(s)
+
+ @classmethod
+ def get_const_ptr_for_unicode(cls, s):
+ return cls.ConstPtr(s)
+
+ @staticmethod
+ def convert_to_floatstorage(arg):
+ return float(arg)
+
+ @staticmethod
+ def ptr_to_int(obj):
+ return id(obj)
+
+ class llhelper(object):
+ pass
+
+ LoopModel.llhelper.BoxRef = LoopModel.BoxRef
+
+ return LoopModel
+
+
+def get_model(use_mock):
+ if use_mock:
+ model = get_mock_model()
+ else:
+ model = get_real_model()
+
+ class ExtendedTreeLoop(model.TreeLoop):
+
+ def getboxes(self):
+ def opboxes(operations):
+ for op in operations:
+ yield op.result
+ for box in op.getarglist():
+ yield box
+ def allboxes():
+ for box in self.inputargs:
+ yield box
+ for box in opboxes(self.operations):
+ yield box
+
+ boxes = Boxes()
+ for box in allboxes():
+ if isinstance(box, model.Box):
+ name = str(box)
+ setattr(boxes, name, box)
+ return boxes
+
+ def setvalues(self, **kwds):
+ boxes = self.getboxes()
+ for name, value in kwds.iteritems():
+ getattr(boxes, name).value = value
+
+ model.ExtendedTreeLoop = ExtendedTreeLoop
+ return model
diff --git a/pypy/jit/tool/test/test_oparser.py
b/pypy/jit/tool/test/test_oparser.py
--- a/pypy/jit/tool/test/test_oparser.py
+++ b/pypy/jit/tool/test/test_oparser.py
@@ -1,227 +1,249 @@
import py
from pypy.rpython.lltypesystem import lltype, llmemory
-from pypy.jit.tool.oparser import parse, ParseError
+from pypy.jit.tool.oparser import parse, OpParser
from pypy.jit.metainterp.resoperation import rop
-from pypy.jit.metainterp.history import AbstractDescr, BoxInt, LoopToken,\
- BoxFloat
+from pypy.jit.metainterp.history import AbstractDescr, BoxInt, LoopToken
-def test_basic_parse():
- x = """
- [i0, i1]
- # a comment
- i2 = int_add(i0, i1)
- i3 = int_sub(i2, 3) # another comment
- finish() # (tricky)
- """
- loop = parse(x)
- assert len(loop.operations) == 3
- assert [op.getopnum() for op in loop.operations] == [rop.INT_ADD,
rop.INT_SUB,
- rop.FINISH]
- assert len(loop.inputargs) == 2
- assert loop.operations[-1].getdescr()
+class BaseTestOparser(object):
-def test_const_ptr_subops():
- x = """
- [p0]
- guard_class(p0, ConstClass(vtable)) []
- """
- S = lltype.Struct('S')
- vtable = lltype.nullptr(S)
- loop = parse(x, None, locals())
- assert len(loop.operations) == 1
- assert loop.operations[0].getdescr()
- assert loop.operations[0].getfailargs() == []
+ OpParser = None
-def test_descr():
- class Xyz(AbstractDescr):
- pass
-
- x = """
- [p0]
- i1 = getfield_gc(p0, descr=stuff)
- """
- stuff = Xyz()
- loop = parse(x, None, locals())
- assert loop.operations[0].getdescr() is stuff
+ def parse(self, *args, **kwds):
+ kwds['OpParser'] = self.OpParser
+ return parse(*args, **kwds)
-def test_after_fail():
- x = """
- [i0]
- guard_value(i0, 3) []
- i1 = int_add(1, 2)
- """
- loop = parse(x, None, {})
- assert len(loop.operations) == 2
+ def test_basic_parse(self):
+ x = """
+ [i0, i1]
+ # a comment
+ i2 = int_add(i0, i1)
+ i3 = int_sub(i2, 3) # another comment
+ finish() # (tricky)
+ """
+ loop = self.parse(x)
+ assert len(loop.operations) == 3
+ assert [op.getopnum() for op in loop.operations] == [rop.INT_ADD,
rop.INT_SUB,
+ rop.FINISH]
+ assert len(loop.inputargs) == 2
+ assert loop.operations[-1].getdescr()
-def test_descr_setfield():
- class Xyz(AbstractDescr):
- pass
-
- x = """
- [p0]
- setfield_gc(p0, 3, descr=stuff)
- """
- stuff = Xyz()
- loop = parse(x, None, locals())
- assert loop.operations[0].getdescr() is stuff
+ def test_const_ptr_subops(self):
+ x = """
+ [p0]
+ guard_class(p0, ConstClass(vtable)) []
+ """
+ S = lltype.Struct('S')
+ vtable = lltype.nullptr(S)
+ loop = self.parse(x, None, locals())
+ assert len(loop.operations) == 1
+ assert loop.operations[0].getdescr()
+ assert loop.operations[0].getfailargs() == []
-def test_boxname():
- x = """
- [i42]
- i50 = int_add(i42, 1)
- """
- loop = parse(x, None, {})
- assert str(loop.inputargs[0]) == 'i42'
- assert str(loop.operations[0].result) == 'i50'
+ def test_descr(self):
+ class Xyz(AbstractDescr):
+ pass
-def test_getboxes():
- x = """
- [i0]
- i1 = int_add(i0, 10)
- """
- loop = parse(x, None, {})
- boxes = loop.getboxes()
- assert boxes.i0 is loop.inputargs[0]
- assert boxes.i1 is loop.operations[0].result
-
-def test_setvalues():
- x = """
- [i0]
- i1 = int_add(i0, 10)
- """
- loop = parse(x, None, {})
- loop.setvalues(i0=32, i1=42)
- assert loop.inputargs[0].value == 32
- assert loop.operations[0].result.value == 42
+ x = """
+ [p0]
+ i1 = getfield_gc(p0, descr=stuff)
+ """
+ stuff = Xyz()
+ loop = self.parse(x, None, locals())
+ assert loop.operations[0].getdescr() is stuff
-def test_boxkind():
- x = """
- [sum0]
- """
- loop = parse(x, None, {}, boxkinds={'sum': BoxInt})
- b = loop.getboxes()
- assert isinstance(b.sum0, BoxInt)
-
-def test_getvar_const_ptr():
- x = '''
- []
- call(ConstPtr(func_ptr))
+ def test_after_fail(self):
+ x = """
+ [i0]
+ guard_value(i0, 3) []
+ i1 = int_add(1, 2)
+ """
+ loop = self.parse(x, None, {})
+ assert len(loop.operations) == 2
+
+ def test_descr_setfield(self):
+ class Xyz(AbstractDescr):
+ pass
+
+ x = """
+ [p0]
+ setfield_gc(p0, 3, descr=stuff)
+ """
+ stuff = Xyz()
+ loop = self.parse(x, None, locals())
+ assert loop.operations[0].getdescr() is stuff
+
+ def test_boxname(self):
+ x = """
+ [i42]
+ i50 = int_add(i42, 1)
+ """
+ loop = self.parse(x, None, {})
+ assert str(loop.inputargs[0]) == 'i42'
+ assert str(loop.operations[0].result) == 'i50'
+
+ def test_getboxes(self):
+ x = """
+ [i0]
+ i1 = int_add(i0, 10)
+ """
+ loop = self.parse(x, None, {})
+ boxes = loop.getboxes()
+ assert boxes.i0 is loop.inputargs[0]
+ assert boxes.i1 is loop.operations[0].result
+
+ def test_setvalues(self):
+ x = """
+ [i0]
+ i1 = int_add(i0, 10)
+ """
+ loop = self.parse(x, None, {})
+ loop.setvalues(i0=32, i1=42)
+ assert loop.inputargs[0].value == 32
+ assert loop.operations[0].result.value == 42
+
+ def test_getvar_const_ptr(self):
+ x = '''
+ []
+ call(ConstPtr(func_ptr))
+ '''
+ TP = lltype.GcArray(lltype.Signed)
+ NULL = lltype.cast_opaque_ptr(llmemory.GCREF, lltype.nullptr(TP))
+ loop = self.parse(x, None, {'func_ptr' : NULL})
+ assert loop.operations[0].getarg(0).value == NULL
+
+ def test_jump_target(self):
+ x = '''
+ []
+ jump()
+ '''
+ loop = self.parse(x)
+ assert loop.operations[0].getdescr() is loop.token
+
+ def test_jump_target_other(self):
+ looptoken = LoopToken()
+ x = '''
+ []
+ jump(descr=looptoken)
+ '''
+ loop = self.parse(x, namespace=locals())
+ assert loop.operations[0].getdescr() is looptoken
+
+ def test_floats(self):
+ x = '''
+ [f0]
+ f1 = float_add(f0, 3.5)
+ '''
+ loop = self.parse(x)
+ box = loop.operations[0].getarg(0)
+ # we cannot use isinstance, because in case of mock the class will be
+ # constructed on the fly
+ assert box.__class__.__name__ == 'BoxFloat'
+
+ def test_debug_merge_point(self):
+ x = '''
+ []
+ debug_merge_point(0, "info")
+ debug_merge_point(0, 'info')
+ debug_merge_point(1, '<some ('other,')> info')
+ debug_merge_point(0, '(stuff) #1')
+ '''
+ loop = self.parse(x)
+ assert loop.operations[0].getarg(1)._get_str() == 'info'
+ assert loop.operations[1].getarg(1)._get_str() == 'info'
+ assert loop.operations[2].getarg(1)._get_str() == "<some ('other,')>
info"
+ assert loop.operations[3].getarg(1)._get_str() == "(stuff) #1"
+
+
+ def test_descr_with_obj_print(self):
+ x = '''
+ [p0]
+ setfield_gc(p0, 1, descr=<SomeDescr>)
+ '''
+ loop = self.parse(x)
+ # assert did not explode
+
+ example_loop_log = '''\
+ # bridge out of Guard12, 6 ops
+ [i0, i1, i2]
+ i4 = int_add(i0, 2)
+ i6 = int_sub(i1, 1)
+ i8 = int_gt(i6, 3)
+ guard_true(i8, descr=<Guard15>) [i4, i6]
+ debug_merge_point('(no jitdriver.get_printable_location!)', 0)
+ jump(i6, i4, descr=<Loop0>)
'''
- TP = lltype.GcArray(lltype.Signed)
- NULL = lltype.cast_opaque_ptr(llmemory.GCREF, lltype.nullptr(TP))
- loop = parse(x, None, {'func_ptr' : NULL})
- assert loop.operations[0].getarg(0).value == NULL
-def test_jump_target():
- x = '''
- []
- jump()
- '''
- loop = parse(x)
- assert loop.operations[0].getdescr() is loop.token
+ def test_parse_no_namespace(self):
+ loop = self.parse(self.example_loop_log, no_namespace=True)
-def test_jump_target_other():
- looptoken = LoopToken()
- x = '''
- []
- jump(descr=looptoken)
- '''
- loop = parse(x, namespace=locals())
- assert loop.operations[0].getdescr() is looptoken
+ def test_attach_comment_to_loop(self):
+ loop = self.parse(self.example_loop_log, no_namespace=True)
+ assert loop.comment == ' # bridge out of Guard12, 6 ops'
-def test_floats():
- x = '''
- [f0]
- f1 = float_add(f0, 3.5)
- '''
- loop = parse(x)
- assert isinstance(loop.operations[0].getarg(0), BoxFloat)
-
-def test_debug_merge_point():
- x = '''
- []
- debug_merge_point(0, "info")
- debug_merge_point(0, 'info')
- debug_merge_point(1, '<some ('other,')> info')
- debug_merge_point(0, '(stuff) #1')
- '''
- loop = parse(x)
- assert loop.operations[0].getarg(1)._get_str() == 'info'
- assert loop.operations[1].getarg(1)._get_str() == 'info'
- assert loop.operations[2].getarg(1)._get_str() == "<some ('other,')> info"
- assert loop.operations[3].getarg(1)._get_str() == "(stuff) #1"
-
+ def test_parse_new_with_comma(self):
+ # this is generated by PYPYJITLOG, check that we can handle it
+ x = '''
+ []
+ p0 = new(, descr=<SizeDescr 12>)
+ '''
+ loop = self.parse(x)
+ assert loop.operations[0].getopname() == 'new'
-def test_descr_with_obj_print():
- x = '''
- [p0]
- setfield_gc(p0, 1, descr=<SomeDescr>)
- '''
- loop = parse(x)
- # assert did not explode
+ def test_no_fail_args(self):
+ x = '''
+ [i0]
+ guard_true(i0, descr=<Guard0>)
+ '''
+ loop = self.parse(x, nonstrict=True)
+ assert loop.operations[0].getfailargs() == []
-example_loop_log = '''\
-# bridge out of Guard12, 6 ops
-[i0, i1, i2]
-i4 = int_add(i0, 2)
-i6 = int_sub(i1, 1)
-i8 = int_gt(i6, 3)
-guard_true(i8, descr=<Guard15>) [i4, i6]
-debug_merge_point('(no jitdriver.get_printable_location!)', 0)
-jump(i6, i4, descr=<Loop0>)
-'''
+ def test_no_inputargs(self):
+ x = '''
+ i2 = int_add(i0, i1)
+ '''
+ loop = self.parse(x, nonstrict=True)
+ assert loop.inputargs == []
+ assert loop.operations[0].getopname() == 'int_add'
-def test_parse_no_namespace():
- loop = parse(example_loop_log, no_namespace=True)
+ def test_offsets(self):
+ x = """
+ [i0, i1]
+ +10: i2 = int_add(i0, i1)
+ i3 = int_add(i2, 3)
+ """
+ # +30: --end of the loop--
+ loop = self.parse(x)
+ assert loop.operations[0].offset == 10
+ assert not hasattr(loop.operations[1], 'offset')
-def test_attach_comment_to_loop():
- loop = parse(example_loop_log, no_namespace=True)
- assert loop.comment == '# bridge out of Guard12, 6 ops'
+ def test_last_offset(self):
+ x = """
+ [i0, i1]
+ +10: i2 = int_add(i0, i1)
+ i3 = int_add(i2, 3)
+ +30: --end of the loop--
+ """
+ loop = self.parse(x)
+ assert len(loop.operations) == 2
+ assert loop.last_offset == 30
-def test_parse_new_with_comma():
- # this is generated by PYPYJITLOG, check that we can handle it
- x = '''
- []
- p0 = new(, descr=<SizeDescr 12>)
- '''
- loop = parse(x)
- assert loop.operations[0].getopname() == 'new'
-def test_no_fail_args():
- x = '''
- [i0]
- guard_true(i0, descr=<Guard0>)
- '''
- loop = parse(x, nonstrict=True)
- assert loop.operations[0].getfailargs() == []
+class TestOpParser(BaseTestOparser):
-def test_no_inputargs():
- x = '''
- i2 = int_add(i0, i1)
- '''
- loop = parse(x, nonstrict=True)
- assert loop.inputargs == []
- assert loop.operations[0].getopname() == 'int_add'
+ OpParser = OpParser
-def test_offsets():
- x = """
- [i0, i1]
- +10: i2 = int_add(i0, i1)
- i3 = int_add(i2, 3)
- """
- # +30: --end of the loop--
- loop = parse(x)
- assert loop.operations[0].offset == 10
- assert not hasattr(loop.operations[1], 'offset')
+ def test_boxkind(self):
+ x = """
+ [sum0]
+ """
+ loop = self.parse(x, None, {}, boxkinds={'sum': BoxInt})
+ b = loop.getboxes()
+ assert isinstance(b.sum0, BoxInt)
-def test_last_offset():
- x = """
- [i0, i1]
- +10: i2 = int_add(i0, i1)
- i3 = int_add(i2, 3)
- +30: --end of the loop--
- """
- loop = parse(x)
- assert len(loop.operations) == 2
- assert loop.last_offset == 30
+
+
+class TestOpParserWithMock(BaseTestOparser):
+
+ class OpParser(OpParser):
+ use_mock_model = True
diff --git a/pypy/tool/jitlogparser/parser.py b/pypy/tool/jitlogparser/parser.py
--- a/pypy/tool/jitlogparser/parser.py
+++ b/pypy/tool/jitlogparser/parser.py
@@ -1,4 +1,5 @@
import re, sys
+
from pypy.jit.metainterp.resoperation import rop, opname
from pypy.jit.tool.oparser import OpParser
@@ -51,6 +52,7 @@
# factory method
Op = Op
+ use_mock_model = True
@classmethod
def parse_from_input(cls, input):
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
