[pypy-svn] r67983 - in pypy/branch/remove-fail/pypy/jit/metainterp: . test
arigo at codespeak.net
arigo at codespeak.net
Tue Sep 29 16:37:45 CEST 2009
Author: arigo
Date: Tue Sep 29 16:37:44 2009
New Revision: 67983
Modified:
pypy/branch/remove-fail/pypy/jit/metainterp/compile.py
pypy/branch/remove-fail/pypy/jit/metainterp/graphpage.py
pypy/branch/remove-fail/pypy/jit/metainterp/history.py
pypy/branch/remove-fail/pypy/jit/metainterp/optimizeopt.py
pypy/branch/remove-fail/pypy/jit/metainterp/pyjitpl.py
pypy/branch/remove-fail/pypy/jit/metainterp/simple_optimize.py
pypy/branch/remove-fail/pypy/jit/metainterp/test/oparser.py
pypy/branch/remove-fail/pypy/jit/metainterp/test/test_basic.py
pypy/branch/remove-fail/pypy/jit/metainterp/test/test_oparser.py
pypy/branch/remove-fail/pypy/jit/metainterp/test/test_optimizefindnode.py
pypy/branch/remove-fail/pypy/jit/metainterp/test/test_optimizeopt.py
Log:
Refactor the world. This is mostly making some of the tests
happy again.
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/compile.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/compile.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/compile.py Tue Sep 29 16:37:44 2009
@@ -193,32 +193,24 @@
class ResumeGuardDescr(ResumeDescr):
counter = 0
+ # this class also gets attributes stored by resume.py code
- def __init__(self, original_greenkey, guard_op):
- ResumeDescr.__init__(self, original_greenkey)
- self.guard_op = guard_op
- # this class also gets attributes stored by resume.py code
+ def store_final_boxes(self, guard_op, boxes):
+ guard_op.fail_args = boxes
+ self.guard_opnum = guard_op.opnum
+ self.fail_arg_types = [box.type for box in boxes]
def handle_fail(self, metainterp_sd):
from pypy.jit.metainterp.pyjitpl import MetaInterp
metainterp = MetaInterp(metainterp_sd)
- fail_op = self.get_guard_op().suboperations[-1] # xxx unhappy
- return metainterp.handle_guard_failure(fail_op, self)
-
- def get_guard_op(self):
- guard_op = self.guard_op
- assert guard_op.is_guard()
- if guard_op.optimized is not None: # should always be the case,
- return guard_op.optimized # except if not optimizing at all
- else:
- return guard_op
+ return metainterp.handle_guard_failure(self)
def compile_and_attach(self, metainterp, new_loop):
# We managed to create a bridge. Attach the new operations
# to the corrsponding guard_op and compile from there
inputargs = metainterp.history.inputargs
if not we_are_translated():
- self.get_guard_op()._debug_suboperations = new_loop.operations
+ self._debug_suboperations = new_loop.operations
send_bridge_to_backend(metainterp.staticdata, self, inputargs,
new_loop.operations)
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/graphpage.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/graphpage.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/graphpage.py Tue Sep 29 16:37:44 2009
@@ -17,13 +17,13 @@
for graph, highlight in graphs:
for op in graph.get_operations():
if is_interesting_guard(op):
- graphs.append((SubGraph(op._debug_suboperations),
+ graphs.append((SubGraph(op.descr._debug_suboperations),
highlight))
graphpage = ResOpGraphPage(graphs, errmsg)
graphpage.display()
def is_interesting_guard(op):
- return hasattr(op, '_debug_suboperations')
+ return hasattr(op.descr, '_debug_suboperations')
class ResOpGraphPage(GraphPage):
@@ -155,7 +155,7 @@
op = operations[opindex]
lines.append(repr(op))
if is_interesting_guard(op):
- tgt = op._debug_suboperations[0]
+ tgt = op.descr._debug_suboperations[0]
tgt_g, tgt_i = self.all_operations[tgt]
self.genedge((graphindex, opstartindex),
(tgt_g, tgt_i),
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/history.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/history.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/history.py Tue Sep 29 16:37:44 2009
@@ -642,7 +642,7 @@
# The TreeLoop class contains a loop or a generalized loop, i.e. a tree
# of operations. Each branch ends in a jump which can go either to
-# the top of the same loop, or to another TreeLoop; or it ends in a FAIL.
+# the top of the same loop, or to another TreeLoop; or it ends in a FINISH.
class Base(object):
"""Common base class for TreeLoop and History."""
@@ -665,16 +665,16 @@
# ops of the kind 'guard_xxx' contain a further list of operations,
# which may itself contain 'guard_xxx' and so on, making a tree.
- def _all_operations(self, omit_fails=False):
+ def _all_operations(self, omit_finish=False):
"NOT_RPYTHON"
result = []
- _list_all_operations(result, self.operations, omit_fails)
+ _list_all_operations(result, self.operations, omit_finish)
return result
def summary(self, adding_insns={}): # for debugging
"NOT_RPYTHON"
insns = adding_insns.copy()
- for op in self._all_operations(omit_fails=True):
+ for op in self._all_operations(omit_finish=True):
opname = op.getopname()
insns[opname] = insns.get(opname, 0) + 1
return insns
@@ -710,13 +710,16 @@
for box in op.args:
if isinstance(box, Box):
assert box in seen
- assert (op.suboperations is not None) == op.is_guard()
if op.is_guard():
- if hasattr(op, '_debug_suboperations'):
- ops = op._debug_suboperations
- else:
- ops = op.suboperations
- TreeLoop.check_consistency_of_branch(ops, seen.copy())
+ assert op.descr is not None
+ if hasattr(op.descr, '_debug_suboperations'):
+ ops = op.descr._debug_suboperations
+ TreeLoop.check_consistency_of_branch(ops, seen.copy())
+ for box in op.fail_args or []:
+ assert isinstance(box, Box)
+ assert box in seen
+ else:
+ assert op.fail_args is None
box = op.result
if box is not None:
assert isinstance(box, Box)
@@ -747,20 +750,16 @@
def __repr__(self):
return '<%s>' % (self.name,)
-def _list_all_operations(result, operations, omit_fails=True):
- if omit_fails and operations[-1].opnum in (rop.FAIL, rop.FINISH):
+def _list_all_operations(result, operations, omit_finish=True):
+ if omit_finish and operations[-1].opnum == rop.FINISH:
# xxx obscure
return
result.extend(operations)
for op in operations:
- if op.is_guard():
- if hasattr(op, '_debug_suboperations'):
- ops = op._debug_suboperations
- else:
- if omit_fails:
- continue
- ops = op.suboperations
- _list_all_operations(result, ops, omit_fails)
+ if op.is_guard() and op.descr:
+ if hasattr(op.descr, '_debug_suboperations'):
+ ops = op.descr._debug_suboperations
+ _list_all_operations(result, ops, omit_finish)
# ____________________________________________________________
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/optimizeopt.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/optimizeopt.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/optimizeopt.py Tue Sep 29 16:37:44 2009
@@ -481,7 +481,6 @@
self.loop.operations = self.newoperations
def emit_operation(self, op, must_clone=True):
- op1 = op
for i in range(len(op.args)):
arg = op.args[i]
if arg in self.values:
@@ -492,21 +491,14 @@
must_clone = False
op.args[i] = box
if op.is_guard():
- self.clone_guard(op, op1)
+ self.store_final_boxes_in_guard(op)
elif op.can_raise():
self.exception_might_have_happened = True
self.newoperations.append(op)
- def _get_faildescr(self, op_fail):
- descr = op_fail.descr
+ def store_final_boxes_in_guard(self, op):
+ descr = op.descr
assert isinstance(descr, compile.ResumeGuardDescr)
- return descr
-
- def clone_guard(self, op2, op1):
- assert len(op1.suboperations) == 1
- op_fail = op1.suboperations[0]
- assert op_fail.opnum == rop.FAIL
- descr = self._get_faildescr(op_fail)
oldboxes = []
args = resume.flatten_resumedata(descr) # xxx expensive
for box in args:
@@ -519,14 +511,7 @@
value = self.values[box]
value.get_args_for_fail(modifier)
newboxes = modifier.finish()
- # XXX we mutate op_fail in-place below, as well as op_fail.descr
- # via the ResumeDataVirtualAdder. That's bad. Hopefully
- # it does not really matter because no-one is going to look again
- # at its unoptimized version. We should really clone it (and
- # the descr too).
- op_fail.args = newboxes
- op2.suboperations = op1.suboperations
- op1.optimized = op2
+ descr.store_final_boxes(op, newboxes)
def clean_fields_of_values(self, descr=None):
if descr is None:
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/pyjitpl.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/pyjitpl.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/pyjitpl.py Tue Sep 29 16:37:44 2009
@@ -917,17 +917,16 @@
moreargs = [box] + extraargs
else:
moreargs = list(extraargs)
- guard_op = metainterp.history.record(opnum, moreargs, None)
original_greenkey = metainterp.resumekey.original_greenkey
- resumedescr = compile.ResumeGuardDescr(original_greenkey, guard_op)
+ resumedescr = compile.ResumeGuardDescr(original_greenkey)
+ guard_op = metainterp.history.record(opnum, moreargs, None,
+ descr=resumedescr)
virtualizable_boxes = None
if metainterp.staticdata.virtualizable_info is not None:
virtualizable_boxes = metainterp.virtualizable_boxes
resume.capture_resumedata(metainterp.framestack, virtualizable_boxes,
resumedescr)
self.metainterp.staticdata.profiler.count_ops(opnum, GUARDS) # count
- op = history.ResOperation(rop.FAIL, [], None, descr=resumedescr)
- guard_op.suboperations = [op]
metainterp.attach_debug_info(guard_op)
self.pc = saved_pc
return guard_op
@@ -1337,10 +1336,10 @@
except GenerateMergePoint, gmp:
return self.designate_target_loop(gmp)
- def handle_guard_failure(self, exec_result, key):
+ def handle_guard_failure(self, key):
from pypy.jit.metainterp.warmspot import ContinueRunningNormallyBase
- resumedescr = self.initialize_state_from_guard_failure(exec_result)
assert isinstance(key, compile.ResumeGuardDescr)
+ resumedescr = self.initialize_state_from_guard_failure(key)
original_greenkey = key.original_greenkey
# notice that here we just put the greenkey
# use -1 to mark that we will have to give up
@@ -1348,10 +1347,9 @@
self.current_merge_points = [(original_greenkey, -1)]
self.resumekey = key
self.seen_can_enter_jit = False
- guard_op = key.get_guard_op()
started_as_blackhole = self.is_blackholing()
try:
- self.prepare_resume_from_failure(guard_op.opnum)
+ self.prepare_resume_from_failure(key.guard_opnum)
self.interpret()
assert False, "should always raise"
except GenerateMergePoint, gmp:
@@ -1538,18 +1536,13 @@
self.initialize_virtualizable(original_boxes)
return original_boxes
- def initialize_state_from_guard_failure(self, guard_failure):
+ def initialize_state_from_guard_failure(self, resumedescr):
# guard failure: rebuild a complete MIFrame stack
self.in_recursion = -1 # always one portal around
- inputargs = self.load_values_from_failure(guard_failure)
- resumedescr = guard_failure.descr
- assert isinstance(resumedescr, compile.ResumeGuardDescr)
+ inputargs = self.load_values_from_failure(resumedescr)
warmrunnerstate = self.staticdata.state
must_compile = warmrunnerstate.must_compile_from_failure(resumedescr)
if must_compile:
- guard_op = resumedescr.get_guard_op()
- suboperations = guard_op.suboperations
- assert suboperations[-1] is guard_failure
self.history = history.History(self.cpu)
self.history.inputargs = inputargs
self.staticdata.profiler.start_tracing()
@@ -1559,16 +1552,17 @@
self.rebuild_state_after_failure(resumedescr, inputargs)
return resumedescr
- def load_values_from_failure(self, guard_failure):
+ def load_values_from_failure(self, resumedescr):
cpu = self.cpu
+ fail_arg_types = resumedescr.fail_arg_types
inputargs = []
- for i in range(len(guard_failure.args)):
- oldbox = guard_failure.args[i] # xxx unhappy
- if isinstance(oldbox, history.BoxInt):
+ for i in range(len(fail_arg_types)):
+ boxtype = fail_arg_types[i]
+ if boxtype == history.INT:
box = history.BoxInt(cpu.get_latest_value_int(i))
- elif isinstance(oldbox, cpu.ts.BoxRef):
+ elif boxtype == history.REF:
box = cpu.ts.BoxRef(cpu.get_latest_value_ref(i))
- elif isinstance(oldbox, history.BoxFloat):
+ elif boxtype == history.FLOAT:
box = history.BoxFloat(cpu.get_latest_value_float(i))
else:
assert False, "should not see %r in guard_failure.args" % (
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/simple_optimize.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/simple_optimize.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/simple_optimize.py Tue Sep 29 16:37:44 2009
@@ -17,11 +17,10 @@
newoperations = []
for op in loop.operations:
if op.is_guard():
- op_fail = op.suboperations[-1]
- descr = op_fail.descr
+ descr = op.descr
assert isinstance(descr, compile.ResumeGuardDescr)
args = resume.flatten_resumedata(descr)
- op_fail.args = args
+ descr.store_final_boxes(op, args)
newoperations.append(op)
loop.operations = newoperations
return None
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/test/oparser.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/test/oparser.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/test/oparser.py Tue Sep 29 16:37:44 2009
@@ -44,8 +44,12 @@
for name, value in kwds.iteritems():
getattr(boxes, name).value = value
+def default_fail_descr(fail_args=None):
+ return BasicFailDescr()
+
+
class OpParser(object):
- def __init__(self, descr, cpu, namespace, type_system, boxkinds, jump_targets, invent_fail_descrs=True):
+ def __init__(self, descr, cpu, namespace, type_system, boxkinds, jump_target, invent_fail_descr=default_fail_descr):
self.descr = descr
self.vars = {}
self.cpu = cpu
@@ -53,9 +57,9 @@
self.type_system = type_system
self.boxkinds = boxkinds or {}
self.jumps = []
- self.jump_targets = jump_targets
+ self.jump_target = jump_target
self._cache = namespace.setdefault('_CACHE_', {})
- self.invent_fail_descrs = invent_fail_descrs
+ self.invent_fail_descr = invent_fail_descr
def box_for_var(self, elem):
try:
@@ -162,27 +166,28 @@
args.append(self.getvar(arg))
except KeyError:
raise ParseError("Unknown var: %s" % arg)
- if hasattr(descr, '_oparser_uses_descr'):
- descr._oparser_uses_descr(self, args)
if rop._GUARD_FIRST <= opnum <= rop._GUARD_LAST:
- if descr is None and self.invent_fail_descrs:
- descr = BasicFailDescr()
i = line.find('[', endnum) + 1
j = line.find(']', i)
if i <= 0 or j <= 0:
raise ParseError("missing fail_args for guard operation")
fail_args = []
- for arg in line[i:j].split(','):
- arg = arg.strip()
- try:
- fail_args.append(self.vars[arg])
- except KeyError:
- raise ParseError("Unknown var in fail_args: %s" % arg)
+ if i < j:
+ for arg in line[i:j].split(','):
+ arg = arg.strip()
+ try:
+ fail_args.append(self.vars[arg])
+ except KeyError:
+ raise ParseError("Unknown var in fail_args: %s" % arg)
+ if descr is None and self.invent_fail_descr:
+ descr = self.invent_fail_descr(fail_args)
+ if hasattr(descr, '_oparser_uses_descr_of_guard'):
+ descr._oparser_uses_descr_of_guard(self, fail_args)
else:
fail_args = None
if opnum == rop.FINISH:
- if descr is None and self.invent_fail_descrs:
- descr = BasicFailDescr()
+ if descr is None and self.invent_fail_descr:
+ descr = self.invent_fail_descr()
return opnum, args, descr, fail_args
def parse_result_op(self, line):
@@ -235,15 +240,12 @@
if num < len(newlines):
raise ParseError("unexpected dedent at line: %s" % newlines[num])
loop = ExtendedTreeLoop("loop")
- if (self.jump_targets is not None and
- len(self.jump_targets) != len(self.jumps)):
- raise ParseError("Wrong number of jump targets")
- if self.jump_targets is None:
- for jump in self.jumps:
- jump.jump_target = None
- else:
- for jump, jump_target in zip(self.jumps, self.jump_targets):
- jump.jump_target = jump_target
+ if len(self.jumps) > 1:
+ raise ParseError("Multiple jumps??")
+ if self.jump_target is not None and len(self.jumps) != 1:
+ raise ParseError("A jump is expected if a jump_target is given")
+ for jump in self.jumps:
+ jump.jump_target = self.jump_target
loop.operations = ops
loop.inputargs = inpargs
return loop
@@ -274,13 +276,15 @@
return base_indent, inpargs
def parse(descr, cpu=None, namespace=None, type_system='lltype',
- boxkinds=None, jump_targets=None, invent_fail_descrs=True):
+ boxkinds=None, jump_target=None,
+ invent_fail_descr=default_fail_descr):
if namespace is None:
namespace = {}
- return OpParser(descr, cpu, namespace, type_system, boxkinds, jump_targets, invent_fail_descrs).parse()
+ return OpParser(descr, cpu, namespace, type_system, boxkinds, jump_target,
+ invent_fail_descr).parse()
def pure_parse(*args, **kwds):
- kwds['invent_fail_descrs'] = False
+ kwds['invent_fail_descr'] = None
return parse(*args, **kwds)
def _box_counter_more_than(s):
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/test/test_basic.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/test/test_basic.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/test/test_basic.py Tue Sep 29 16:37:44 2009
@@ -224,8 +224,8 @@
if self.basic:
found = 0
for op in get_stats().loops[0]._all_operations():
- if op.getopname() == 'fail':
- liveboxes = op.args
+ if op.getopname() == 'guard_true':
+ liveboxes = op.fail_args
assert len(liveboxes) == 3
for box in liveboxes:
assert isinstance(box, history.BoxInt)
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/test/test_oparser.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/test/test_oparser.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/test/test_oparser.py Tue Sep 29 16:37:44 2009
@@ -11,27 +11,26 @@
# a comment
i2 = int_add(i0, i1)
i3 = int_sub(i2, 3) # another comment
- fail() # (tricky)
+ finish() # (tricky)
"""
loop = parse(x)
assert len(loop.operations) == 3
assert [op.opnum for op in loop.operations] == [rop.INT_ADD, rop.INT_SUB,
- rop.FAIL]
+ rop.FINISH]
assert len(loop.inputargs) == 2
assert loop.operations[-1].descr
def test_const_ptr_subops():
x = """
[p0]
- guard_class(p0, ConstClass(vtable))
- fail()
+ guard_class(p0, ConstClass(vtable)) []
"""
S = lltype.Struct('S')
vtable = lltype.nullptr(S)
loop = parse(x, None, locals())
assert len(loop.operations) == 1
- assert len(loop.operations[0].suboperations) == 1
- assert loop.operations[0].suboperations[-1].descr
+ assert loop.operations[0].descr
+ assert loop.operations[0].fail_args == []
def test_descr():
class Xyz(AbstractDescr):
@@ -48,8 +47,7 @@
def test_after_fail():
x = """
[i0]
- guard_value(i0, 3)
- fail()
+ guard_value(i0, 3) []
i1 = int_add(1, 2)
"""
loop = parse(x, None, {})
@@ -128,21 +126,9 @@
jump()
'''
obj = object()
- loop = parse(x, jump_targets=[obj])
+ loop = parse(x, jump_target=obj)
assert loop.operations[0].jump_target is obj
-def test_jump_target_self():
- x = '''
- [i2]
- guard_true(i2)
- jump()
- jump()
- '''
- obj = object()
- loop = parse(x, jump_targets=[obj, None])
- assert loop.operations[-1].jump_target is None
- assert loop.operations[0].suboperations[0].jump_target is obj
-
def test_debug_merge_point():
x = '''
[]
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/test/test_optimizefindnode.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/test/test_optimizefindnode.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/test/test_optimizefindnode.py Tue Sep 29 16:37:44 2009
@@ -16,7 +16,7 @@
from pypy.jit.metainterp.specnode import VirtualArraySpecNode
from pypy.jit.metainterp.specnode import VirtualStructSpecNode
from pypy.jit.metainterp.specnode import ConstantSpecNode
-from pypy.jit.metainterp.test.oparser import pure_parse as parse
+from pypy.jit.metainterp.test.oparser import parse
def test_sort_descrs():
class PseudoDescr(AbstractDescr):
@@ -159,11 +159,13 @@
namespace = locals()
class BaseTest(object):
+ invent_fail_descr = None
def parse(self, s, boxkinds=None):
return parse(s, self.cpu, self.namespace,
type_system=self.type_system,
- boxkinds=boxkinds)
+ boxkinds=boxkinds,
+ invent_fail_descr=self.invent_fail_descr)
def unpack_specnodes(self, text):
#
@@ -229,8 +231,7 @@
ops = """
[i]
i0 = int_sub(i, 1)
- guard_value(i0, 0)
- fail(i0)
+ guard_value(i0, 0) [i0]
jump(i0)
"""
boxes, getnode = self.find_nodes(ops, 'Not')
@@ -327,8 +328,7 @@
def test_find_nodes_new_3(self):
ops = """
[sum, p1]
- guard_class(p1, ConstClass(node_vtable))
- fail()
+ guard_class(p1, ConstClass(node_vtable)) []
i1 = getfield_gc(p1, descr=valuedescr)
i2 = int_sub(i1, 1)
sum2 = int_add(sum, i1)
@@ -380,11 +380,9 @@
def test_find_nodes_new_aliasing_1(self):
ops = """
[sum, p1]
- guard_class(p1, ConstClass(node_vtable))
- fail()
+ guard_class(p1, ConstClass(node_vtable)) []
p3 = getfield_gc(p1, descr=nextdescr)
- guard_class(p3, ConstClass(node_vtable))
- fail()
+ guard_class(p3, ConstClass(node_vtable)) []
i1 = getfield_gc(p1, descr=valuedescr)
i2 = int_sub(i1, 1)
sum2 = int_add(sum, i1)
@@ -412,8 +410,7 @@
def test_find_nodes_new_mismatch(self):
ops = """
[p1]
- guard_class(p1, ConstClass(node_vtable))
- fail()
+ guard_class(p1, ConstClass(node_vtable)) []
p2 = new_with_vtable(ConstClass(node_vtable2))
jump(p2)
"""
@@ -424,10 +421,8 @@
def test_find_nodes_new_aliasing_mismatch(self):
ops = """
[p0, p1]
- guard_class(p0, ConstClass(node_vtable))
- fail()
- guard_class(p1, ConstClass(node_vtable2))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
+ guard_class(p1, ConstClass(node_vtable2)) []
p2 = new_with_vtable(ConstClass(node_vtable2))
jump(p2, p2)
"""
@@ -465,41 +460,29 @@
p0 = new_with_vtable(ConstClass(node_vtable))
p1 = new_with_vtable(ConstClass(node_vtable))
i1 = oononnull(p0)
- guard_true(i1)
- fail()
+ guard_true(i1) []
i2 = ooisnull(p0)
- guard_false(i2)
- fail()
+ guard_false(i2) []
i3 = ooisnot(p0, NULL)
- guard_true(i3)
- fail()
+ guard_true(i3) []
i4 = oois(p0, NULL)
- guard_false(i4)
- fail()
+ guard_false(i4) []
i5 = ooisnot(NULL, p0)
- guard_true(i5)
- fail()
+ guard_true(i5) []
i6 = oois(NULL, p0)
- guard_false(i6)
- fail()
+ guard_false(i6) []
i7 = ooisnot(p0, p1)
- guard_true(i7)
- fail()
+ guard_true(i7) []
i8 = oois(p0, p1)
- guard_false(i8)
- fail()
+ guard_false(i8) []
i9 = ooisnot(p0, p2)
- guard_true(i9)
- fail()
+ guard_true(i9) []
i10 = oois(p0, p2)
- guard_false(i10)
- fail()
+ guard_false(i10) []
i11 = ooisnot(p2, p1)
- guard_true(i11)
- fail()
+ guard_true(i11) []
i12 = oois(p2, p1)
- guard_false(i12)
- fail()
+ guard_false(i12) []
jump(p0, p1, p2)
"""
self.find_nodes(ops, '''Virtual(node_vtable),
@@ -519,8 +502,7 @@
ops = """
[p0]
i0 = getfield_gc(p0, descr=valuedescr)
- guard_value(i0, 5)
- fail()
+ guard_value(i0, 5) []
p1 = new_with_vtable(ConstClass(node_vtable))
# the field 'value' has its default value of 0
jump(p1)
@@ -532,8 +514,7 @@
def test_find_nodes_nonvirtual_guard_class(self):
ops = """
[p1]
- guard_class(p1, ConstClass(node_vtable))
- fail(p1)
+ guard_class(p1, ConstClass(node_vtable)) [p1]
jump(p1)
"""
self.find_nodes(ops, 'Not')
@@ -574,8 +555,7 @@
def test_find_nodes_p123_guard_class(self):
ops = """
[i1, p2, p3]
- guard_class(p3, ConstClass(node_vtable))
- fail(i1, p2, p3)
+ guard_class(p3, ConstClass(node_vtable)) [i1, p2, p3]
i3 = getfield_gc(p3, descr=valuedescr)
escape(i3)
p1 = new_with_vtable(ConstClass(node_vtable))
@@ -717,8 +697,7 @@
def test_find_nodes_guard_value_constant(self):
ops = """
[p1]
- guard_value(p1, ConstPtr(myptr))
- fail()
+ guard_value(p1, ConstPtr(myptr)) []
jump(ConstPtr(myptr))
"""
self.find_nodes(ops, 'Constant(myptr)')
@@ -726,8 +705,7 @@
def test_find_nodes_guard_value_constant_mismatch(self):
ops = """
[p1]
- guard_value(p1, ConstPtr(myptr2))
- fail()
+ guard_value(p1, ConstPtr(myptr2)) []
jump(ConstPtr(myptr))
"""
py.test.raises(InvalidLoop, self.find_nodes, ops, None)
@@ -736,8 +714,7 @@
ops = """
[p1]
escape(p1)
- guard_value(p1, ConstPtr(myptr))
- fail()
+ guard_value(p1, ConstPtr(myptr)) []
jump(ConstPtr(myptr))
"""
self.find_nodes(ops, 'Constant(myptr)')
@@ -745,8 +722,7 @@
def test_find_nodes_guard_value_same_as_constant(self):
ops = """
[p1]
- guard_value(p1, ConstPtr(myptr))
- fail()
+ guard_value(p1, ConstPtr(myptr)) []
p2 = same_as(ConstPtr(myptr))
jump(p2)
"""
@@ -837,25 +813,18 @@
ops = """
[p12]
i16 = ooisnull(p12)
- guard_false(i16)
- fail()
- guard_class(p12, ConstClass(node_vtable))
- fail()
- guard_class(p12, ConstClass(node_vtable))
- fail()
+ guard_false(i16) []
+ guard_class(p12, ConstClass(node_vtable)) []
+ guard_class(p12, ConstClass(node_vtable)) []
i22 = getfield_gc_pure(p12, descr=valuedescr)
escape(i22)
i25 = ooisnull(p12)
- guard_false(i25)
- fail()
- guard_class(p12, ConstClass(node_vtable))
- fail()
- guard_class(p12, ConstClass(node_vtable))
- fail()
+ guard_false(i25) []
+ guard_class(p12, ConstClass(node_vtable)) []
+ guard_class(p12, ConstClass(node_vtable)) []
i29 = getfield_gc_pure(p12, descr=valuedescr)
i31 = int_add_ovf(i29, 1)
- guard_no_overflow()
- fail()
+ guard_no_overflow() []
p33 = new_with_vtable(ConstClass(node_vtable)) # NODE
setfield_gc(p33, i31, descr=valuedescr)
#
@@ -864,13 +833,10 @@
p38 = new_with_vtable(ConstClass(u_vtable)) # U
setfield_gc(p38, p35, descr=onedescr)
i39 = ooisnull(p38)
- guard_false(i39)
- fail()
+ guard_false(i39) []
i40 = oononnull(p38)
- guard_true(i40)
- fail()
- guard_class(p38, ConstClass(u_vtable))
- fail()
+ guard_true(i40) []
+ guard_class(p38, ConstClass(u_vtable)) []
p42 = getfield_gc(p38, descr=onedescr) # Array(NODE)
i43 = arraylen_gc(p42, descr=arraydescr3)
i45 = int_sub(i43, 0)
@@ -879,23 +845,19 @@
p47 = new_array(i45, descr=arraydescr3) # Array(NODE)
setfield_gc(p46, p47, descr=ddescr)
i48 = int_lt(0, i43)
- guard_true(i48)
- fail()
+ guard_true(i48) []
p49 = getarrayitem_gc(p42, 0, descr=arraydescr3) # NODE
p50 = getfield_gc(p46, descr=ddescr) # Array(NODE)
setarrayitem_gc(p50, 0, p49, descr=arraydescr3)
i52 = int_lt(1, i43)
- guard_false(i52)
- fail()
+ guard_false(i52) []
i53 = getfield_gc(p46, descr=cdescr)
i55 = int_ne(i53, 1)
- guard_false(i55)
- fail()
+ guard_false(i55) []
p56 = getfield_gc(p46, descr=ddescr) # Array(NODE)
p58 = getarrayitem_gc(p56, 0, descr=arraydescr3) # NODE
i59 = ooisnull(p38)
- guard_false(i59)
- fail()
+ guard_false(i59) []
jump(p58)
"""
self.find_nodes(ops, 'Virtual(node_vtable, valuedescr=Not)')
@@ -1040,8 +1002,7 @@
ops = """
[p1]
p2 = getfield_gc(p1, descr=nextdescr)
- guard_class(p2, ConstClass(node_vtable))
- fail()
+ guard_class(p2, ConstClass(node_vtable)) []
jump(p2)
"""
self.find_bridge(ops, 'Not', 'Not')
@@ -1085,20 +1046,20 @@
nextdescr=Virtual(node_vtable,
nextdescr=Not)))''')
- def test_bridge_to_fail(self):
+ def test_bridge_to_finish(self):
ops = """
[i1]
i2 = int_add(i1, 5)
- fail(i2)
+ finish(i2)
"""
self.find_bridge(ops, 'Not', 'Not')
- def test_bridge_virtual_to_fail(self):
+ def test_bridge_virtual_to_finish(self):
ops = """
[i1]
p1 = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p1, i1, descr=valuedescr)
- fail(p1)
+ finish(p1)
"""
self.find_bridge(ops, 'Not', 'Not')
Modified: pypy/branch/remove-fail/pypy/jit/metainterp/test/test_optimizeopt.py
==============================================================================
--- pypy/branch/remove-fail/pypy/jit/metainterp/test/test_optimizeopt.py (original)
+++ pypy/branch/remove-fail/pypy/jit/metainterp/test/test_optimizeopt.py Tue Sep 29 16:37:44 2009
@@ -12,7 +12,7 @@
from pypy.jit.metainterp.history import AbstractDescr, ConstInt, BoxInt
from pypy.jit.metainterp import resume, executor, compile
from pypy.jit.metainterp.resoperation import rop, opname, ResOperation
-from pypy.jit.metainterp.test.oparser import pure_parse as parse
+from pypy.jit.metainterp.test.oparser import pure_parse
class FakeFrame(object):
parent_resumedata_snapshot = None
@@ -28,12 +28,8 @@
b0 = BoxInt()
b1 = BoxInt()
opt = optimizeopt.Optimizer(None, None)
- op = ResOperation(rop.GUARD_TRUE, [], None)
- op.suboperations = [
- ResOperation(rop.FAIL, [], None)
- ]
- fdescr = ResumeGuardDescr(None, None)
- op.suboperations[-1].descr = fdescr
+ fdescr = ResumeGuardDescr(None)
+ op = ResOperation(rop.GUARD_TRUE, [], None, descr=fdescr)
# setup rd data
fi = [("code0", 1, 2), ("code1", 3, -1)]
fdescr.rd_virtuals = None
@@ -43,10 +39,8 @@
snapshot0 = resume.Snapshot(None, [b0])
fdescr.rd_snapshot = resume.Snapshot(snapshot0, [b1])
#
- op1 = op
- opt.clone_guard(op, op1)
- assert op1.optimized is op
- assert op1.suboperations[-1].args == [b0, b1]
+ opt.store_final_boxes_in_guard(op)
+ assert op.fail_args == [b0, b1]
assert fdescr.rd_nums == [0, -1, 1, -1]
assert fdescr.rd_virtuals is None
assert fdescr.rd_consts == []
@@ -71,8 +65,10 @@
else:
remap[op2.result] = op1.result
assert op1.descr == op2.descr
- if op1.suboperations:
- assert equaloplists(op1.suboperations, op2.suboperations, remap)
+ if op1.fail_args or op2.fail_args:
+ assert len(op1.fail_args) == len(op2.fail_args)
+ for x, y in zip(op1.fail_args, op2.fail_args):
+ assert x == remap.get(y, y)
assert len(oplist1) == len(oplist2)
print '-'*57
return True
@@ -81,55 +77,56 @@
ops = """
[i0]
i1 = int_add(i0, 1)
- guard_true(i1)
- i2 = int_add(i1, 1)
- fail(i2)
+ i2 = int_add(i1, 1)
+ guard_true(i1) [i2]
jump(i1)
"""
namespace = {}
- loop1 = parse(ops, namespace=namespace)
- loop2 = parse(ops, namespace=namespace)
- loop3 = parse(ops.replace("i2 = int_add", "i2 = int_sub"),
- namespace=namespace)
+ loop1 = pure_parse(ops, namespace=namespace)
+ loop2 = pure_parse(ops, namespace=namespace)
+ loop3 = pure_parse(ops.replace("i2 = int_add", "i2 = int_sub"),
+ namespace=namespace)
assert equaloplists(loop1.operations, loop2.operations)
py.test.raises(AssertionError,
"equaloplists(loop1.operations, loop3.operations)")
-def test_equaloplists_remap():
- ops1 = """
+def test_equaloplists_fail_args():
+ ops = """
[i0]
i1 = int_add(i0, 1)
- guard_true(i1)
- i2 = int_add(i1, 1)
- fail(i2)
- jump(i1)
- """
- ops2 = """
- [i3]
- i1 = int_add(i3, 1)
- guard_true(i1)
- i5 = int_add(i1, 1)
- fail(i5)
+ i2 = int_add(i1, 1)
+ guard_true(i1) [i2, i1]
jump(i1)
"""
- loop1 = parse(ops1)
- loop2 = parse(ops2)
+ namespace = {}
+ loop1 = pure_parse(ops, namespace=namespace)
+ loop2 = pure_parse(ops.replace("[i2, i1]", "[i2, i0]"),
+ namespace=namespace)
py.test.raises(AssertionError,
"equaloplists(loop1.operations, loop2.operations)")
- i0 = loop1.inputargs[0]
- i3 = loop2.inputargs[0]
- i2 = loop1.operations[1].suboperations[0].result
- i5 = loop2.operations[1].suboperations[0].result
- assert equaloplists(loop1.operations, loop2.operations,
- {i3: i0, i5: i2})
# ____________________________________________________________
-class Storage:
+class Storage(compile.ResumeGuardDescr):
"for tests."
+ def __init__(self):
+ pass
+ def store_final_boxes(self, op, boxes):
+ op.fail_args = boxes
+ def __eq__(self, other):
+ return type(self) is type(other) # xxx obscure
class BaseTestOptimizeOpt(BaseTest):
+ def invent_fail_descr(self, fail_args):
+ if fail_args is None:
+ return None
+ descr = Storage()
+ descr.rd_frame_info_list = resume.FrameInfo(None, FakeFrame())
+ descr.rd_snapshot = resume.Snapshot(None, fail_args)
+ descr.rd_virtuals = None
+ return descr
+
def assert_equal(self, optimized, expected):
assert len(optimized.inputargs) == len(expected.inputargs)
remap = {}
@@ -158,22 +155,7 @@
assert loop.operations[-1].opnum == rop.JUMP
loop.operations[-1].jump_target = loop
#
- Optimizer = optimizeopt.Optimizer
- old_get_faildescr = Optimizer._get_faildescr
- def _get_faildescr(self, op_fail):
- if op_fail.descr is None:
- descr = Storage()
- descr.rd_frame_info_list = resume.FrameInfo(None,
- FakeFrame())
- descr.rd_snapshot = resume.Snapshot(None, op_fail.args)
- descr.rd_virtuals = None
- return descr
- return old_get_faildescr(self, op_fail)
- Optimizer._get_faildescr = _get_faildescr
- try:
- optimize_loop_1(self.cpu, loop)
- finally:
- Optimizer._get_faildescr = old_get_faildescr.im_func
+ optimize_loop_1(self.cpu, loop)
#
expected = self.parse(optops)
self.assert_equal(loop, expected)
@@ -182,8 +164,7 @@
ops = """
[i]
i0 = int_sub(i, 1)
- guard_value(i0, 0)
- fail(i0)
+ guard_value(i0, 0) [i0]
jump(i)
"""
self.optimize_loop(ops, 'Not', ops)
@@ -193,13 +174,10 @@
[]
i0 = int_add(2, 3)
i1 = int_is_true(i0)
- guard_true(i1)
- fail()
+ guard_true(i1) []
i2 = bool_not(i1)
- guard_false(i2)
- fail()
- guard_value(i0, 5)
- fail()
+ guard_false(i2) []
+ guard_value(i0, 5) []
jump()
"""
expected = """
@@ -247,16 +225,13 @@
def test_remove_guard_class_1(self):
ops = """
[p0]
- guard_class(p0, ConstClass(node_vtable))
- fail()
- guard_class(p0, ConstClass(node_vtable))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
+ guard_class(p0, ConstClass(node_vtable)) []
jump(p0)
"""
expected = """
[p0]
- guard_class(p0, ConstClass(node_vtable))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
jump(p0)
"""
self.optimize_loop(ops, 'Not', expected)
@@ -266,8 +241,7 @@
[i0]
p0 = new_with_vtable(ConstClass(node_vtable))
escape(p0)
- guard_class(p0, ConstClass(node_vtable))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
jump(i0)
"""
expected = """
@@ -282,8 +256,7 @@
ops = """
[i0]
p0 = same_as(ConstPtr(myptr))
- guard_class(p0, ConstClass(node_vtable))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
jump(i0)
"""
expected = """
@@ -296,11 +269,9 @@
ops = """
[]
i0 = escape()
- guard_value(i0, 0)
- fail()
+ guard_value(i0, 0) []
i1 = int_add(i0, 1)
- guard_value(i1, 1)
- fail()
+ guard_value(i1, 1) []
i2 = int_add(i1, 2)
escape(i2)
jump()
@@ -308,8 +279,7 @@
expected = """
[]
i0 = escape()
- guard_value(i0, 0)
- fail()
+ guard_value(i0, 0) []
escape(3)
jump()
"""
@@ -318,8 +288,7 @@
def test_remove_guard_value_if_constant(self):
ops = """
[p1]
- guard_value(p1, ConstPtr(myptr))
- fail()
+ guard_value(p1, ConstPtr(myptr)) []
jump(ConstPtr(myptr))
"""
expected = """
@@ -331,20 +300,16 @@
def test_ooisnull_oononnull_1(self):
ops = """
[p0]
- guard_class(p0, ConstClass(node_vtable))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
i0 = oononnull(p0)
- guard_true(i0)
- fail()
+ guard_true(i0) []
i1 = ooisnull(p0)
- guard_false(i1)
- fail()
+ guard_false(i1) []
jump(p0)
"""
expected = """
[p0]
- guard_class(p0, ConstClass(node_vtable))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
jump(p0)
"""
self.optimize_loop(ops, 'Not', expected)
@@ -353,18 +318,15 @@
ops = """
[i0]
i1 = int_is_true(i0)
- guard_true(i1)
- fail()
+ guard_true(i1) []
i2 = int_is_true(i0)
- guard_true(i2)
- fail()
+ guard_true(i2) []
jump(i0)
"""
expected = """
[i0]
i1 = int_is_true(i0)
- guard_true(i1)
- fail()
+ guard_true(i1) []
jump(i0)
"""
self.optimize_loop(ops, 'Not', expected)
@@ -373,36 +335,30 @@
ops = """
[p0]
i0 = oononnull(p0) # p0 != NULL
- guard_true(i0)
- fail()
+ guard_true(i0) []
i1 = ooisnull(p0)
- guard_false(i1)
- fail()
+ guard_false(i1) []
jump(p0)
"""
expected = """
[p0]
i0 = oononnull(p0)
- guard_true(i0)
- fail()
+ guard_true(i0) []
jump(p0)
"""
self.optimize_loop(ops, 'Not', expected)
ops = """
[p0]
i1 = ooisnull(p0)
- guard_false(i1)
- fail()
+ guard_false(i1) []
i0 = oononnull(p0) # p0 != NULL
- guard_true(i0)
- fail()
+ guard_true(i0) []
jump(p0)
"""
expected = """
[p0]
i1 = ooisnull(p0)
- guard_false(i1)
- fail()
+ guard_false(i1) []
jump(p0)
"""
self.optimize_loop(ops, 'Not', expected)
@@ -412,19 +368,16 @@
[]
p0 = escape()
i0 = ooisnull(p0)
- guard_true(i0)
- fail()
+ guard_true(i0) []
i1 = oononnull(p0)
- guard_false(i1)
- fail()
+ guard_false(i1) []
jump()
"""
expected = """
[]
p0 = escape()
i0 = ooisnull(p0)
- guard_true(i0)
- fail()
+ guard_true(i0) []
jump()
"""
self.optimize_loop(ops, '', expected)
@@ -432,19 +385,16 @@
[]
p0 = escape()
i0 = oononnull(p0)
- guard_false(i0)
- fail()
+ guard_false(i0) []
i1 = ooisnull(p0)
- guard_true(i1)
- fail()
+ guard_true(i1) []
jump()
"""
expected = """
[]
p0 = escape()
i0 = oononnull(p0)
- guard_false(i0)
- fail()
+ guard_false(i0) []
jump()
"""
self.optimize_loop(ops, '', expected)
@@ -455,19 +405,16 @@
pv = new_with_vtable(ConstClass(node_vtable))
setfield_gc(pv, p0, descr=valuedescr)
i0 = oononnull(p0) # p0 != NULL
- guard_true(i0)
- fail()
+ guard_true(i0) []
p1 = getfield_gc(pv, descr=valuedescr)
i1 = ooisnull(p1)
- guard_false(i1)
- fail()
+ guard_false(i1) []
jump(p0)
"""
expected = """
[p0]
i0 = oononnull(p0)
- guard_true(i0)
- fail()
+ guard_true(i0) []
jump(p0)
"""
self.optimize_loop(ops, 'Not', expected)
@@ -475,26 +422,20 @@
def test_oois_1(self):
ops = """
[p0]
- guard_class(p0, ConstClass(node_vtable))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
i0 = ooisnot(p0, NULL)
- guard_true(i0)
- fail()
+ guard_true(i0) []
i1 = oois(p0, NULL)
- guard_false(i1)
- fail()
+ guard_false(i1) []
i2 = ooisnot(NULL, p0)
- guard_true(i0)
- fail()
+ guard_true(i0) []
i3 = oois(NULL, p0)
- guard_false(i1)
- fail()
+ guard_false(i1) []
jump(p0)
"""
expected = """
[p0]
- guard_class(p0, ConstClass(node_vtable))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
jump(p0)
"""
self.optimize_loop(ops, 'Not', expected)
@@ -504,23 +445,17 @@
[p0]
setfield_gc(p0, 5, descr=valuedescr) # forces p0 != NULL
i0 = ooisnot(p0, NULL)
- guard_true(i0)
- fail()
+ guard_true(i0) []
i1 = oois(p0, NULL)
- guard_false(i1)
- fail()
+ guard_false(i1) []
i2 = ooisnot(NULL, p0)
- guard_true(i0)
- fail()
+ guard_true(i0) []
i3 = oois(NULL, p0)
- guard_false(i1)
- fail()
+ guard_false(i1) []
i4 = oononnull(p0)
- guard_true(i4)
- fail()
+ guard_true(i4) []
i5 = ooisnull(p0)
- guard_false(i5)
- fail()
+ guard_false(i5) []
jump(p0)
"""
expected = """
@@ -534,8 +469,7 @@
ops = """
[]
i = int_add(5, 3)
- guard_value(i, 8)
- fail()
+ guard_value(i, 8) []
jump()
"""
expected = """
@@ -548,8 +482,7 @@
ops = """
[]
p1 = escape()
- guard_value(p1, ConstPtr(myptr))
- fail()
+ guard_value(p1, ConstPtr(myptr)) []
jump()
"""
self.optimize_loop(ops, '', ops)
@@ -604,16 +537,12 @@
def test_fold_guard_no_exception(self):
ops = """
[i]
- guard_no_exception()
- fail()
+ guard_no_exception() []
i1 = int_add(i, 3)
- guard_no_exception()
- fail()
+ guard_no_exception() []
i2 = call(i1)
- guard_no_exception()
- fail(i1, i2)
- guard_no_exception()
- fail()
+ guard_no_exception() [i1, i2]
+ guard_no_exception() []
i3 = call(i2)
jump(i1) # the exception is considered lost when we loop back
"""
@@ -621,8 +550,7 @@
[i]
i1 = int_add(i, 3)
i2 = call(i1)
- guard_no_exception()
- fail(i1, i2)
+ guard_no_exception() [i1, i2]
i3 = call(i2)
jump(i1)
"""
@@ -667,41 +595,29 @@
ops = """
[p0, p1, p2]
i1 = oononnull(p0)
- guard_true(i1)
- fail()
+ guard_true(i1) []
i2 = ooisnull(p0)
- guard_false(i2)
- fail()
+ guard_false(i2) []
i3 = ooisnot(p0, NULL)
- guard_true(i3)
- fail()
+ guard_true(i3) []
i4 = oois(p0, NULL)
- guard_false(i4)
- fail()
+ guard_false(i4) []
i5 = ooisnot(NULL, p0)
- guard_true(i5)
- fail()
+ guard_true(i5) []
i6 = oois(NULL, p0)
- guard_false(i6)
- fail()
+ guard_false(i6) []
i7 = ooisnot(p0, p1)
- guard_true(i7)
- fail()
+ guard_true(i7) []
i8 = oois(p0, p1)
- guard_false(i8)
- fail()
+ guard_false(i8) []
i9 = ooisnot(p0, p2)
- guard_true(i9)
- fail()
+ guard_true(i9) []
i10 = oois(p0, p2)
- guard_false(i10)
- fail()
+ guard_false(i10) []
i11 = ooisnot(p2, p1)
- guard_true(i11)
- fail()
+ guard_true(i11) []
i12 = oois(p2, p1)
- guard_false(i12)
- fail()
+ guard_false(i12) []
jump(p0, p1, p2)
"""
expected = """
@@ -720,26 +636,19 @@
expected2 = """
[p0, p1, p2]
i1 = oononnull(p0)
- guard_true(i1)
- fail()
+ guard_true(i1) []
i7 = ooisnot(p0, p1)
- guard_true(i7)
- fail()
+ guard_true(i7) []
i8 = oois(p0, p1)
- guard_false(i8)
- fail()
+ guard_false(i8) []
i9 = ooisnot(p0, p2)
- guard_true(i9)
- fail()
+ guard_true(i9) []
i10 = oois(p0, p2)
- guard_false(i10)
- fail()
+ guard_false(i10) []
i11 = ooisnot(p2, p1)
- guard_true(i11)
- fail()
+ guard_true(i11) []
i12 = oois(p2, p1)
- guard_false(i12)
- fail()
+ guard_false(i12) []
jump(p0, p1, p2)
"""
self.optimize_loop(ops, 'Not, Not, Not', expected2)
@@ -748,16 +657,14 @@
ops = """
[p0]
i0 = getfield_gc(p0, descr=valuedescr)
- guard_value(i0, 0)
- fail()
+ guard_value(i0, 0) []
p1 = new_with_vtable(ConstClass(node_vtable))
# the field 'value' has its default value of 0
jump(p1)
"""
expected = """
[i]
- guard_value(i, 0)
- fail()
+ guard_value(i, 0) []
jump(0)
"""
# the 'expected' is sub-optimal, but it should be done by another later
@@ -784,8 +691,7 @@
def test_virtual_4(self):
ops = """
[i0, p0]
- guard_class(p0, ConstClass(node_vtable))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
i1 = getfield_gc(p0, descr=valuedescr)
i2 = int_sub(i1, 1)
i3 = int_add(i0, i1)
@@ -805,8 +711,7 @@
def test_virtual_5(self):
ops = """
[i0, p0]
- guard_class(p0, ConstClass(node_vtable))
- fail()
+ guard_class(p0, ConstClass(node_vtable)) []
i1 = getfield_gc(p0, descr=valuedescr)
i2 = int_sub(i1, 1)
i3 = int_add(i0, i1)
@@ -959,8 +864,7 @@
[i1]
p1 = new_array(3, descr=arraydescr)
i3 = arraylen_gc(p1, descr=arraydescr)
- guard_value(i3, 3)
- fail()
+ guard_value(i3, 3) []
setarrayitem_gc(p1, 1, i1, descr=arraydescr)
setarrayitem_gc(p1, 0, 25, descr=arraydescr)
i2 = getarrayitem_gc(p1, 1, descr=arraydescr)
@@ -977,7 +881,7 @@
[i1, p0]
setarrayitem_gc(p0, 0, i1, descr=arraydescr)
i2 = ooisnull(p0)
- guard_false(i2)
+ guard_false(i2) []
p1 = new_array(i1, descr=arraydescr)
jump(i1, p1)
"""
@@ -995,8 +899,7 @@
i1 = getarrayitem_gc(p1, 0, descr=arraydescr)
i2 = getarrayitem_gc(p1, 1, descr=arraydescr)
i3 = int_sub(i1, i2)
- guard_value(i3, 15)
- fail()
+ guard_value(i3, 15) []
p2 = new_array(2, descr=arraydescr)
setarrayitem_gc(p2, 1, i0, descr=arraydescr)
setarrayitem_gc(p2, 0, 20, descr=arraydescr)
@@ -1005,8 +908,7 @@
expected = """
[i0, i1, i2]
i3 = int_sub(i1, i2)
- guard_value(i3, 15)
- fail()
+ guard_value(i3, 15) []
jump(i0, 20, i0)
"""
self.optimize_loop(ops, 'Not, VArray(arraydescr, Not, Not)', expected)
@@ -1161,8 +1063,7 @@
[p1]
i1 = getfield_gc(p1, descr=valuedescr)
i2 = int_add_ovf(i1, 14)
- guard_no_overflow()
- fail()
+ guard_no_overflow() []
i3 = getfield_gc(p1, descr=valuedescr)
escape(i2)
escape(i3)
@@ -1172,8 +1073,7 @@
[p1]
i1 = getfield_gc(p1, descr=valuedescr)
i2 = int_add_ovf(i1, 14)
- guard_no_overflow()
- fail()
+ guard_no_overflow() []
escape(i2)
escape(i1)
jump(p1)
@@ -1221,8 +1121,7 @@
def test_duplicate_getfield_guard_value_const(self):
ops = """
[p1]
- guard_value(p1, ConstPtr(myptr))
- fail()
+ guard_value(p1, ConstPtr(myptr)) []
i1 = getfield_gc(p1, descr=valuedescr)
i2 = getfield_gc(ConstPtr(myptr), descr=valuedescr)
escape(i1)
@@ -1266,8 +1165,7 @@
[i0, p1]
p4 = getfield_gc(p1, descr=nextdescr)
i2 = ooisnull(p4)
- guard_false(i2)
- fail()
+ guard_false(i2) []
escape(p4)
#
p2 = new_with_vtable(ConstClass(node_vtable))
@@ -1278,8 +1176,7 @@
expected = """
[i0, p4]
i2 = ooisnull(p4)
- guard_false(i2)
- fail()
+ guard_false(i2) []
escape(p4)
#
p3 = escape()
@@ -1293,8 +1190,7 @@
[i0, p1]
p4 = getarrayitem_gc(p1, 0, descr=arraydescr2)
i2 = ooisnull(p4)
- guard_false(i2)
- fail()
+ guard_false(i2) []
escape(p4)
#
p2 = new_array(1, descr=arraydescr2)
@@ -1305,8 +1201,7 @@
expected = """
[i0, p4]
i2 = ooisnull(p4)
- guard_false(i2)
- fail()
+ guard_false(i2) []
escape(p4)
#
p3 = escape()
@@ -1319,8 +1214,7 @@
ops = """
[p1]
i1 = ooisnull(p1)
- guard_true(i1)
- fail()
+ guard_true(i1) []
#
p2 = new_with_vtable(ConstClass(node_vtable))
jump(p2)
@@ -1332,8 +1226,7 @@
py.test.skip("this would fail if we had Fixed again in the specnodes")
ops = """
[p1]
- guard_class(p1, ConstClass(node_vtable2))
- fail()
+ guard_class(p1, ConstClass(node_vtable2)) []
#
p2 = new_with_vtable(ConstClass(node_vtable))
escape(p2) # prevent it from staying Virtual
@@ -1347,8 +1240,7 @@
[p1]
p2 = getfield_gc(p1, descr=nextdescr)
i1 = ooisnull(p2)
- guard_true(i1)
- fail()
+ guard_true(i1) []
#
p3 = new_with_vtable(ConstClass(node_vtable))
p4 = new_with_vtable(ConstClass(node_vtable))
@@ -1364,15 +1256,14 @@
def make_fail_descr(self):
class FailDescr(compile.ResumeGuardDescr):
args_seen = []
- def _oparser_uses_descr(self, oparse, args):
+ def _oparser_uses_descr_of_guard(self, oparse, fail_args):
# typically called twice, before and after optimization
if len(self.args_seen) == 0:
fdescr.rd_frame_info_list = resume.FrameInfo(None,
FakeFrame())
- fdescr.rd_snapshot = resume.Snapshot(None, args)
+ fdescr.rd_snapshot = resume.Snapshot(None, fail_args)
fdescr.virtuals = None
- self.args_seen.append((args, oparse))
-
+ self.args_seen.append((fail_args, oparse))
#
fdescr = instantiate(FailDescr)
self.fdescr = fdescr
@@ -1475,14 +1366,12 @@
i4 = getfield_gc(p1, descr=valuedescr)
#
i2 = int_add(10, 5)
- guard_true(i1)
- fail(i2, i4, descr=fdescr)
+ guard_true(i1, descr=fdescr) [i2, i4]
jump(i1, i4)
"""
expected = """
[i1, i3]
- guard_true(i1)
- fail(i3, descr=fdescr)
+ guard_true(i1, descr=fdescr) [i3]
jump(1, i3)
"""
self.optimize_loop(ops, 'Not, Not', expected)
@@ -1495,14 +1384,12 @@
p1 = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p1, i2, descr=valuedescr)
setfield_gc(p1, p1, descr=nextdescr)
- guard_true(i1)
- fail(p1, descr=fdescr)
+ guard_true(i1, descr=fdescr) [p1]
jump(i1, i2)
"""
expected = """
[i1, i2]
- guard_true(i1)
- fail(i2, descr=fdescr)
+ guard_true(i1, descr=fdescr) [i2]
jump(1, i2)
"""
self.optimize_loop(ops, 'Not, Not', expected)
@@ -1520,14 +1407,12 @@
setfield_gc(p1, p2, descr=nextdescr)
setfield_gc(p2, i2, descr=valuedescr)
setfield_gc(p2, p3, descr=nextdescr)
- guard_true(i1)
- fail(p1, i3, descr=fdescr)
+ guard_true(i1, descr=fdescr) [p1, i3]
jump(i2, i1, i3, p3)
"""
expected = """
[i1, i2, i3, p3]
- guard_true(i1)
- fail(i3, i2, p3, descr=fdescr)
+ guard_true(i1, descr=fdescr) [i3, i2, p3]
jump(i2, 1, i3, p3)
"""
self.optimize_loop(ops, 'Not, Not, Not, Not', expected)
@@ -1550,14 +1435,12 @@
setfield_gc(p1, i2, descr=valuedescr)
setfield_gc(p1, p2, descr=nextdescr)
setfield_gc(p2, i2, descr=valuedescr)
- guard_true(i1)
- fail(i4, %s, i3, descr=fdescr)
+ guard_true(i1, descr=fdescr) [i4, %s, i3]
jump(i1, i2, i3)
"""
expected = """
[i1, i2, i3]
- guard_true(i1)
- fail(i3, i2, descr=fdescr)
+ guard_true(i1, descr=fdescr) [i3, i2]
jump(1, i2, i3)
"""
self.optimize_loop(ops % arg, 'Not, Not, Not', expected)
@@ -1576,14 +1459,12 @@
setfield_gc(p1, p2, descr=nextdescr)
setfield_gc(p2, i2, descr=valuedescr)
setfield_gc(p2, p1, descr=nextdescr) # a cycle
- guard_true(i1)
- fail(p1, i3, p2, i4, descr=fdescr)
+ guard_true(i1, descr=fdescr) [p1, i3, p2, i4]
jump(i2, i1, i3, i4)
"""
expected = """
[i1, i2, i3, i4]
- guard_true(i1)
- fail(i3, i4, i2, descr=fdescr)
+ guard_true(i1, descr=fdescr) [i3, i4, i2]
jump(i2, 1, i3, i4)
"""
self.optimize_loop(ops, 'Not, Not, Not, Not', expected)
@@ -1596,16 +1477,14 @@
self.make_fail_descr()
ops = """
[p0, i0, i1]
- guard_true(i0)
- fail(p0, descr=fdescr)
+ guard_true(i0, descr=fdescr) [p0]
p1 = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p1, i1, descr=valuedescr)
jump(p1, i1, i1)
"""
expected = """
[i1b, i0, i1]
- guard_true(i0)
- fail(i1b, descr=fdescr)
+ guard_true(i0, descr=fdescr) [i1b]
jump(i1, i1, i1)
"""
self.optimize_loop(ops, '''Virtual(node_vtable, valuedescr=Not),
@@ -1621,15 +1500,13 @@
p1 = new_array(3, descr=arraydescr)
setarrayitem_gc(p1, 1, i1, descr=arraydescr)
setarrayitem_gc(p1, 0, 25, descr=arraydescr)
- guard_true(i1)
- fail(p1, descr=fdescr)
+ guard_true(i1, descr=fdescr) [p1]
i2 = getarrayitem_gc(p1, 1, descr=arraydescr)
jump(i2)
"""
expected = """
[i1]
- guard_true(i1)
- fail(i1, descr=fdescr)
+ guard_true(i1, descr=fdescr) [i1]
jump(1)
"""
self.optimize_loop(ops, 'Not', expected)
@@ -1644,16 +1521,14 @@
p2 = new(descr=ssize)
setfield_gc(p2, i1, descr=adescr)
setfield_gc(p2, p1, descr=bdescr)
- guard_true(i1)
- fail(p2, descr=fdescr)
+ guard_true(i1, descr=fdescr) [p2]
i3 = getfield_gc(p2, descr=adescr)
p3 = getfield_gc(p2, descr=bdescr)
jump(i3, p3)
"""
expected = """
[i1, p1]
- guard_true(i1)
- fail(i1, p1, descr=fdescr)
+ guard_true(i1, descr=fdescr) [i1, p1]
jump(1, p1)
"""
self.optimize_loop(ops, 'Not, Not', expected)
@@ -1671,8 +1546,7 @@
setfield_gc(p5s, i2, descr=adescr)
setfield_gc(p5s, p7v, descr=bdescr)
setarrayitem_gc(p1a, 1, p5s, descr=arraydescr2)
- guard_true(i1)
- fail(p1a, descr=fdescr)
+ guard_true(i1, descr=fdescr) [p1a]
p2s = new(descr=ssize)
p3v = new_with_vtable(ConstClass(node_vtable))
p4a = new_array(2, descr=arraydescr2)
@@ -1684,8 +1558,7 @@
"""
expected = """
[i1, ia, iv, pnull, i2]
- guard_true(i1)
- fail(ia, iv, i2, descr=fdescr)
+ guard_true(i1, descr=fdescr) [ia, iv, i2]
jump(1, 1, i2, NULL, i2)
"""
self.optimize_loop(ops, '''
More information about the Pypy-commit
mailing list