[pypy-svn] r79323 - in pypy/branch/jit-unroll-loops/pypy/jit/metainterp: . optimizeopt test
hakanardo at codespeak.net
hakanardo at codespeak.net
Sun Nov 21 19:57:57 CET 2010
Author: hakanardo
Date: Sun Nov 21 19:57:54 2010
New Revision: 79323
Modified:
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/compile.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/history.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimize.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/__init__.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/unroll.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/pyjitpl.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/simple_optimize.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_basic.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_compile.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_greenfield.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_loop.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeopt.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_recursive.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_send.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_virtual.py
Log:
When possible, create a short preamble as the operations in the
preamble but not in the loop, making this short preamble followed by
one iteration of the loop equivalent to the original preamble. The
short preamble is stored in the loop_token and inlined at the end of
each bridge, which then can jump to the loop directly instead of
jumping to the preamble. When it was not possible to create such a
short preamble the bridge will fall back to jumping to the original
preamble.
Bridges inherits virtuals from the loop and this approach now allows
them to stay virtual and part of the inlined short preamble to be
optimized away. However other loop invariant operations are currently not
inherited which results in them being recalculated at the end of each
guard.
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/compile.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/compile.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/compile.py Sun Nov 21 19:57:54 2010
@@ -541,7 +541,8 @@
op = new_loop.operations[-1]
if not isinstance(target_loop_token, TerminatingLoopToken):
# normal case
- op.setdescr(target_loop_token) # patch the jump target
+ #op.setdescr(target_loop_token) # patch the jump target
+ pass
else:
# The target_loop_token is a pseudo loop token,
# e.g. loop_tokens_done_with_this_frame_void[0]
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/history.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/history.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/history.py Sun Nov 21 19:57:54 2010
@@ -490,6 +490,9 @@
def _get_str(self): # for debugging only
return self.constbox()._get_str()
+ def forget_value(self):
+ raise NotImplementedError
+
class BoxInt(Box):
type = INT
_attrs_ = ('value',)
@@ -502,6 +505,9 @@
assert isinstance(value, Symbolic)
self.value = value
+ def forget_value(self):
+ self.value = 0
+
def clonebox(self):
return BoxInt(self.value)
@@ -537,6 +543,9 @@
assert isinstance(floatval, float)
self.value = floatval
+ def forget_value(self):
+ self.value = 0.0
+
def clonebox(self):
return BoxFloat(self.value)
@@ -569,6 +578,9 @@
assert lltype.typeOf(value) == llmemory.GCREF
self.value = value
+ def forget_value(self):
+ self.value = lltype.nullptr(llmemory.GCREF.TO)
+
def clonebox(self):
return BoxPtr(self.value)
@@ -613,6 +625,9 @@
assert ootype.typeOf(value) is ootype.Object
self.value = value
+ def forget_value(self):
+ self.value = ootype.NULL
+
def clonebox(self):
return BoxObj(self.value)
@@ -726,6 +741,7 @@
was compiled; but the LoopDescr remains alive and points to the
generated assembler.
"""
+ short_preamble = None
terminating = False # see TerminatingLoopToken in compile.py
outermost_jitdriver_sd = None
# and more data specified by the backend when the loop is compiled
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimize.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimize.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimize.py Sun Nov 21 19:57:54 2010
@@ -37,6 +37,7 @@
bridge.operations[-1].setdescr(old_loop_token) # patch jump target
optimize_bridge_1(metainterp_sd, bridge)
return old_loop_tokens[0]
+ #return bridge.operations[-1].getdescr()
return None
# ____________________________________________________________
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/__init__.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/__init__.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/__init__.py Sun Nov 21 19:57:54 2010
@@ -5,19 +5,21 @@
from pypy.jit.metainterp.optimizeopt.heap import OptHeap
from pypy.jit.metainterp.optimizeopt.fficall import OptFfiCall
from pypy.jit.metainterp.optimizeopt.string import OptString
-from pypy.jit.metainterp.optimizeopt.unroll import optimize_unroll
+from pypy.jit.metainterp.optimizeopt.unroll import optimize_unroll, OptInlineShortPreamble
def optimize_loop_1(metainterp_sd, loop, unroll=True):
"""Optimize loop.operations to remove internal overheadish operations.
"""
opt_str = OptString()
- optimizations = [OptIntBounds(),
+ optimizations = [OptInlineShortPreamble(),
+ OptIntBounds(),
OptRewrite(),
OptVirtualize(),
opt_str,
OptHeap(),
OptFfiCall(),
]
+
if unroll:
opt_str.enabled = False # FIXME: Workaround to disable string optimisation
# during preamble but to keep it during the loop
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/unroll.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/unroll.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/unroll.py Sun Nov 21 19:57:54 2010
@@ -2,6 +2,7 @@
from pypy.jit.metainterp.resoperation import rop, ResOperation
from pypy.jit.metainterp.compile import ResumeGuardDescr
from pypy.jit.metainterp.resume import Snapshot
+from pypy.jit.metainterp.history import TreeLoop, LoopToken
# FXIME: Introduce some VirtualOptimizer super class instead
@@ -17,9 +18,11 @@
def __init__(self, metainterp_sd, loop, optimizations):
self.optimizer = Optimizer(metainterp_sd, loop, optimizations)
self.cloned_operations = []
+ self.originalop = {}
for op in self.optimizer.loop.operations:
- self.cloned_operations.append(op.clone())
-
+ newop = op.clone()
+ self.cloned_operations.append(newop)
+ self.originalop[newop] = op
def propagate_all_forward(self):
loop = self.optimizer.loop
@@ -49,6 +52,52 @@
loop.operations = self.optimizer.newoperations
+ short = self.create_short_preamble(loop.preamble.operations,
+ loop.preamble.inputargs,
+ loop.operations,
+ loop.inputargs,
+ loop.token)
+ if short:
+ if False:
+ # FIXME: This should save some memory but requires
+ # a lot of tests to be fixed...
+ loop.preamble.operations = short
+ short_loop = loop.preamble
+ else:
+ short_loop = TreeLoop('short preamble')
+ short_loop.inputargs = loop.preamble.inputargs[:]
+ short_loop.operations = short
+
+ assert isinstance(loop.preamble.token, LoopToken)
+ loop.preamble.token.short_preamble = short_loop
+
+ # Clone ops and boxes to get private versions and forget the
+ # values to allow them to be freed
+ boxmap = {}
+ for i in range(len(short_loop.inputargs)):
+ box = short_loop.inputargs[i]
+ newbox = box.clonebox()
+ boxmap[box] = newbox
+ newbox.forget_value()
+ short_loop.inputargs[i] = newbox
+ for i in range(len(short)):
+ oldop = short[i]
+ op = oldop.clone()
+ args = []
+ for a in op.getarglist():
+ if not isinstance(a, Const):
+ a = boxmap[a]
+ args.append(a)
+ op.initarglist(args)
+ box = op.result
+ if box:
+ newbox = box.clonebox()
+ boxmap[box] = newbox
+ newbox.forget_value()
+ op.result = newbox
+ short[i] = op
+
+
def inline(self, loop_operations, loop_args, jump_args):
self.argmap = argmap = {}
assert len(loop_args) == len(jump_args)
@@ -71,17 +120,18 @@
# This loop is equivalent to the main optimization loop in
# Optimizer.propagate_all_forward
for newop in loop_operations:
+ #print 'N:', newop
if newop.getopnum() == rop.JUMP:
args = inputargs
else:
args = newop.getarglist()
newop.initarglist([self.inline_arg(a) for a in args])
- #print 'P:', newop
if newop.result:
old_result = newop.result
newop.result = newop.result.clonebox()
argmap[old_result] = newop.result
+ #print 'P:', newop
descr = newop.getdescr()
if isinstance(descr, ResumeGuardDescr):
@@ -131,3 +181,127 @@
new_snapshot = Snapshot(self.inline_snapshot(snapshot.prev), boxes)
self.snapshot_map[snapshot] = new_snapshot
return new_snapshot
+
+ def sameop(self, preambleop, loopop):
+ #if preambleop.getopnum() != loopop.getopnum():
+ # return False
+ #pargs = preambleop.getarglist()
+ #largs = loopop.getarglist()
+ #if len(pargs) != len(largs):
+ # return False
+ try:
+ return self.originalop[loopop] is preambleop
+ except KeyError:
+ return False
+
+ def create_short_preamble(self, preamble, preambleargs,
+ loop, inputargs, token):
+ #return None # Dissable
+
+ short_preamble = []
+ loop_i = preamble_i = 0
+ while loop_i < len(loop)-1 and preamble_i < len(preamble)-1:
+ if self.sameop(preamble[preamble_i], loop[loop_i]):
+ loop_i += 1
+ preamble_i += 1
+ else:
+ short_preamble.append(preamble[preamble_i])
+ preamble_i += 1
+
+ if loop_i < len(loop)-1:
+ print "Loop contains ops not in preamble???"
+ return None
+ while preamble_i < len(preamble)-1:
+ short_preamble.append(preamble[preamble_i])
+ preamble_i += 1
+
+ jumpargs = [None] * len(inputargs)
+ allboxes = preambleargs[:]
+ for op in short_preamble:
+ if op.result:
+ allboxes.append(op.result)
+
+ for result in allboxes:
+ box = self.inline_arg(result)
+ for i in range(len(inputargs)):
+ b = inputargs[i]
+ if self.optimizer.getvalue(box) is self.optimizer.getvalue(b):
+ jumpargs[i] = result
+ break
+
+ for a in jumpargs:
+ if a is None:
+ print "Unable to find all input arguments???"
+ return None
+
+ jmp = ResOperation(rop.JUMP, jumpargs[:], None)
+ jmp.setdescr(token)
+ short_preamble.append(jmp)
+
+ # Make sure it is safe to move the instrucions in short_preamble
+ # to the top making short_preamble followed by loop equvivalent
+ # to preamble
+ for op in short_preamble:
+ opnum = op.getopnum()
+ if (op.is_always_pure() or
+ opnum == rop.GETFIELD_GC or
+ opnum == rop.GETARRAYITEM_GC or
+ opnum == rop.JUMP):
+ continue
+ return None
+ # FIXME: Turn guards into conditional jumps to the preamble
+
+ # Check that boxes used as arguemts are produced. Might not be
+ # needed, but let's play it safe.
+ seen = {}
+ for box in preambleargs:
+ seen[box] = True
+ for op in short_preamble:
+ for box in op.getarglist():
+ if box not in seen:
+ print "Op arguments not produced???"
+ return None
+ if op.result:
+ seen[op.result] = True
+
+
+ return short_preamble
+
+class OptInlineShortPreamble(Optimization):
+ def reconstruct_for_next_iteration(self, optimizer, valuemap):
+ return self
+
+ def propagate_forward(self, op):
+ if op.getopnum() == rop.JUMP:
+ descr = op.getdescr()
+ assert isinstance(descr, LoopToken)
+ short = descr.short_preamble
+ if short:
+ self.inline(short.operations, short.inputargs, op.getarglist())
+ return
+ self.emit_operation(op)
+
+
+
+ def inline(self, loop_operations, loop_args, jump_args):
+ self.argmap = argmap = {}
+ assert len(loop_args) == len(jump_args)
+ for i in range(len(loop_args)):
+ argmap[loop_args[i]] = jump_args[i]
+
+ for op in loop_operations:
+ newop = op.clone()
+ args = newop.getarglist()
+ newop.initarglist([self.inline_arg(a) for a in args])
+
+ if newop.result:
+ old_result = newop.result
+ newop.result = newop.result.clonebox()
+ argmap[old_result] = newop.result
+
+ self.emit_operation(newop)
+
+ def inline_arg(self, arg):
+ if isinstance(arg, Const):
+ return arg
+ return self.argmap[arg]
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/pyjitpl.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/pyjitpl.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/pyjitpl.py Sun Nov 21 19:57:54 2010
@@ -1804,6 +1804,8 @@
old_loop_tokens = self.get_compiled_merge_points(greenkey)
if len(old_loop_tokens) == 0:
return
+ #if self.resumekey.guard_opnum == rop.GUARD_CLASS:
+ # return # Kepp tracing for another iteration
self.history.record(rop.JUMP, live_arg_boxes[num_green_args:], None)
target_loop_token = compile.compile_new_bridge(self, old_loop_tokens,
self.resumekey)
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/simple_optimize.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/simple_optimize.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/simple_optimize.py Sun Nov 21 19:57:54 2010
@@ -42,8 +42,14 @@
descr.store_final_boxes(op, newboxes)
newoperations.extend(transform(op))
loop.operations = newoperations
+ jumpop = newoperations[-1]
+ if jumpop.getopnum() == rop.JUMP:
+ jumpop.setdescr(loop.token)
return None
def optimize_bridge(metainterp_sd, old_loops, loop):
optimize_loop(metainterp_sd, [], loop)
+ jumpop = loop.operations[-1]
+ if jumpop.getopnum() == rop.JUMP:
+ jumpop.setdescr(old_loops[0])
return old_loops[0]
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_basic.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_basic.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_basic.py Sun Nov 21 19:57:54 2010
@@ -356,7 +356,7 @@
return res
res = self.meta_interp(f, [6, 32])
assert res == 3427
- self.check_loop_count(2)
+ self.check_loop_count(3)
def test_loop_invariant_mul_bridge_maintaining1(self):
myjitdriver = JitDriver(greens = [], reds = ['y', 'res', 'x'])
@@ -372,10 +372,11 @@
return res
res = self.meta_interp(f, [6, 32])
assert res == 1167
- self.check_loop_count(2)
- self.check_loops({'int_add': 1, 'int_lt': 1,
- 'int_sub': 1, 'guard_false': 1,
- 'jump': 1})
+ self.check_loop_count(3)
+ self.check_loops({'int_add': 2, 'int_lt': 1,
+ 'int_sub': 2, 'guard_false': 1,
+ 'jump': 2,
+ 'int_gt': 1, 'guard_true': 1, 'int_mul': 1})
def test_loop_invariant_mul_bridge_maintaining2(self):
@@ -387,18 +388,17 @@
myjitdriver.jit_merge_point(x=x, y=y, res=res)
z = x * x
res += z
- if y<8:
+ if y<16:
res += z
y -= 1
return res
- res = self.meta_interp(f, [6, 16])
- assert res == 828
- self.check_loop_count(2)
- self.check_loops({'int_add': 1, 'int_lt': 1,
- 'int_sub': 1, 'guard_false': 1,
- 'jump': 1})
-
-
+ res = self.meta_interp(f, [6, 32])
+ assert res == 1692
+ self.check_loop_count(3)
+ self.check_loops({'int_add': 2, 'int_lt': 1,
+ 'int_sub': 2, 'guard_false': 1,
+ 'jump': 2,
+ 'int_gt': 1, 'guard_true': 1, 'int_mul': 1})
def test_loop_invariant_intbox(self):
myjitdriver = JitDriver(greens = [], reds = ['y', 'res', 'x'])
@@ -450,7 +450,9 @@
assert res == f(6, 15)
gc.collect()
- assert not [wr for wr in wr_loops if wr()]
+ #assert not [wr for wr in wr_loops if wr()]
+ for loop in [wr for wr in wr_loops if wr()]:
+ assert loop().name == 'short preamble'
def test_string(self):
def f(n):
@@ -1804,7 +1806,8 @@
assert res == 8
py.test.raises(AssertGreenFailed, self.interp_operations, f, [8, 0])
- def test_mutiple_specialied_versions(self):
+ def test_multiple_specialied_versions(self):
+ py.test.skip('Not supported yet')
myjitdriver = JitDriver(greens = [], reds = ['y', 'x', 'res'])
class Base:
def __init__(self, val):
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_compile.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_compile.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_compile.py Sun Nov 21 19:57:54 2010
@@ -85,7 +85,7 @@
metainterp.history.inputargs = loop.inputargs[:]
#
loop_tokens = []
- loop_token = compile_new_loop(metainterp, loop_tokens, 0)
+ loop_token = compile_new_loop(metainterp, loop_tokens, [], 0)
assert loop_tokens == [loop_token]
assert loop_token.number == 1
assert staticdata.globaldata.loopnumbering == 2
@@ -101,7 +101,7 @@
metainterp.history.operations = loop.operations[:]
metainterp.history.inputargs = loop.inputargs[:]
#
- loop_token_2 = compile_new_loop(metainterp, loop_tokens, 0)
+ loop_token_2 = compile_new_loop(metainterp, loop_tokens, [], 0)
assert loop_token_2 is loop_token
assert loop_tokens == [loop_token]
assert len(cpu.seen) == 0
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_greenfield.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_greenfield.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_greenfield.py Sun Nov 21 19:57:54 2010
@@ -49,7 +49,7 @@
#
res = self.meta_interp(g, [7])
assert res == -22
- self.check_loop_count(4)
+ self.check_loop_count(6)
self.check_loops(guard_value=0)
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_loop.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_loop.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_loop.py Sun Nov 21 19:57:54 2010
@@ -87,7 +87,10 @@
return res * 2
res = self.meta_interp(f, [6, 33], policy=StopAtXPolicy(l))
assert res == f(6, 33)
- self.check_loop_count(2)
+ if self.optimizer == OPTIMIZER_FULL:
+ self.check_loop_count(3)
+ else:
+ self.check_loop_count(2)
def test_alternating_loops(self):
myjitdriver = JitDriver(greens = [], reds = ['pattern'])
@@ -101,8 +104,11 @@
pass
pattern >>= 1
return 42
- self.meta_interp(f, [0xF0F0])
- self.check_loop_count(2)
+ self.meta_interp(f, [0xF0F0F0])
+ if self.optimizer == OPTIMIZER_FULL:
+ self.check_loop_count(3)
+ else:
+ self.check_loop_count(2)
def test_interp_simple(self):
myjitdriver = JitDriver(greens = ['i'], reds = ['x', 'y'])
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeopt.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeopt.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeopt.py Sun Nov 21 19:57:54 2010
@@ -7,7 +7,8 @@
import pypy.jit.metainterp.optimizeopt.virtualize as virtualize
from pypy.jit.metainterp.optimizeopt import optimize_loop_1
from pypy.jit.metainterp.optimizeutil import InvalidLoop
-from pypy.jit.metainterp.history import AbstractDescr, ConstInt, BoxInt, TreeLoop
+from pypy.jit.metainterp.history import AbstractDescr, ConstInt, BoxInt
+from pypy.jit.metainterp.history import TreeLoop, LoopToken
from pypy.jit.metainterp.jitprof import EmptyProfiler
from pypy.jit.metainterp import executor, compile, resume, history
from pypy.jit.metainterp.resoperation import rop, opname, ResOperation
@@ -167,6 +168,7 @@
self.loop = loop
loop.preamble = TreeLoop('preamble')
loop.preamble.inputargs = loop.inputargs
+ loop.preamble.token = LoopToken()
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
if hasattr(self, 'vrefinfo'):
metainterp_sd.virtualref_info = self.vrefinfo
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_recursive.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_recursive.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_recursive.py Sun Nov 21 19:57:54 2010
@@ -1016,7 +1016,7 @@
res = self.meta_interp(portal, [2, 0], inline=True,
policy=StopAtXPolicy(residual))
assert res == portal(2, 0)
- self.check_loops(call_assembler=3, everywhere=True)
+ self.check_loops(call_assembler=4, everywhere=True)
def test_inline_without_hitting_the_loop(self):
driver = JitDriver(greens = ['codeno'], reds = ['i'],
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_send.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_send.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_send.py Sun Nov 21 19:57:54 2010
@@ -162,6 +162,7 @@
y -= 1
return 42
policy = StopAtXPolicy(externfn)
+
for j in range(69, 75):
res = self.meta_interp(f, [j], policy=policy)
assert res == 42
@@ -169,8 +170,8 @@
self.check_enter_count(3)
self.check_loop_count(3)
else:
- self.check_enter_count(5)
- self.check_loop_count(5)
+ self.check_enter_count_at_most(5)
+ self.check_loop_count_at_most(5)
def test_oosend_guard_failure(self):
myjitdriver = JitDriver(greens = [], reds = ['x', 'y', 'w'])
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_virtual.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_virtual.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_virtual.py Sun Nov 21 19:57:54 2010
@@ -164,7 +164,7 @@
getfield_gc=0, setfield_gc=0)
def test_two_loops_with_virtual(self):
- py.test.skip("We don't know how to virtualize across bridges right now")
+ #py.test.skip("We don't know how to virtualize across bridges right now")
myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
def f(n):
node = self._new()
More information about the Pypy-commit
mailing list