[pypy-svn] r74812 - in pypy/branch/blackhole-improvement/pypy/jit: codewriter metainterp metainterp/test
arigo at codespeak.net
arigo at codespeak.net
Thu May 27 16:27:09 CEST 2010
Author: arigo
Date: Thu May 27 16:27:07 2010
New Revision: 74812
Modified:
pypy/branch/blackhole-improvement/pypy/jit/codewriter/call.py
pypy/branch/blackhole-improvement/pypy/jit/codewriter/jtransform.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/compile.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/optimizeopt.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_recursive.py
Log:
Start to support recursive calls, but give up for now (with py.test.mark.xfail()).
Modified: pypy/branch/blackhole-improvement/pypy/jit/codewriter/call.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/codewriter/call.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/codewriter/call.py Thu May 27 16:27:07 2010
@@ -245,3 +245,7 @@
self.jitdriver = jitdriver
else:
assert self.jitdriver is jitdriver
+
+ def getjitdriver(self):
+ assert self.jitdriver is not None, "order dependency issue?"
+ return self.jitdriver
Modified: pypy/branch/blackhole-improvement/pypy/jit/codewriter/jtransform.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/codewriter/jtransform.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/codewriter/jtransform.py Thu May 27 16:27:07 2010
@@ -283,12 +283,11 @@
op1 = [op1, SpaceOperation('-live-', [], None)]
return op1
- def handle_regular_call(self, op, targetgraph=None):
+ def handle_regular_call(self, op):
"""A direct_call turns into the operation 'inline_call_xxx' if it
is calling a function that we want to JIT. The initial arg of
'inline_call_xxx' is the JitCode of the called function."""
- if targetgraph is None:
- [targetgraph] = self.callcontrol.graphs_from(op)
+ [targetgraph] = self.callcontrol.graphs_from(op)
jitcode = self.callcontrol.get_jitcode(targetgraph,
called_from=self.graph)
op0 = self.rewrite_call(op, 'inline_call', [jitcode])
@@ -317,7 +316,13 @@
def handle_recursive_call(self, op):
ops = self.promote_greens(op.args[1:])
targetgraph = self.callcontrol.portal_graph
- return ops + self.handle_regular_call(op, targetgraph)
+ num_green_args = len(self.callcontrol.getjitdriver().greens)
+ args = (self.make_three_lists(op.args[1:1+num_green_args]) +
+ self.make_three_lists(op.args[1+num_green_args:]))
+ kind = getkind(op.result.concretetype)[0]
+ op0 = SpaceOperation('recursive_call_%s' % kind, args, op.result)
+ op1 = SpaceOperation('-live-', [], None)
+ return ops + [op0, op1]
handle_residual_indirect_call = handle_residual_call
@@ -689,10 +694,8 @@
return op
def promote_greens(self, args):
- jitdriver = self.callcontrol.jitdriver
- assert jitdriver is not None, "order dependency issue?"
ops = []
- num_green_args = len(jitdriver.greens)
+ num_green_args = len(self.callcontrol.getjitdriver().greens)
for v in args[:num_green_args]:
if isinstance(v, Variable) and v.concretetype is not lltype.Void:
kind = getkind(v.concretetype)
@@ -709,7 +712,7 @@
def handle_jit_marker__jit_merge_point(self, op):
assert self.portal, "jit_merge_point in non-main graph!"
ops = self.promote_greens(op.args[2:])
- num_green_args = len(self.callcontrol.jitdriver.greens)
+ num_green_args = len(self.callcontrol.getjitdriver().greens)
args = (self.make_three_lists(op.args[2:2+num_green_args]) +
self.make_three_lists(op.args[2+num_green_args:]))
op1 = SpaceOperation('jit_merge_point', args, None)
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py Thu May 27 16:27:07 2010
@@ -800,6 +800,45 @@
XXX
raise LeaveFrame
+ def get_portal_runner(self):
+ metainterp_sd = self.builder.metainterp_sd
+ fnptr = llmemory.cast_ptr_to_adr(metainterp_sd.portal_runner_ptr)
+ calldescr = metainterp_sd.portal_code.calldescr
+ return fnptr, calldescr
+
+ @arguments("self", "I", "R", "F", "I", "R", "F", returns="i")
+ def bhimpl_recursive_call_i(self, greens_i, greens_r, greens_f,
+ reds_i, reds_r, reds_f):
+ fnptr, calldescr = self.get_portal_runner()
+ return self.cpu.bh_call_i(fnptr, calldescr,
+ greens_i + reds_i,
+ greens_r + reds_r,
+ greens_f + reds_f)
+ @arguments("self", "I", "R", "F", "I", "R", "F", returns="r")
+ def bhimpl_recursive_call_r(self, greens_i, greens_r, greens_f,
+ reds_i, reds_r, reds_f):
+ fnptr, calldescr = self.get_portal_runner()
+ return self.cpu.bh_call_r(fnptr, calldescr,
+ greens_i + reds_i,
+ greens_r + reds_r,
+ greens_f + reds_f)
+ @arguments("self", "I", "R", "F", "I", "R", "F", returns="f")
+ def bhimpl_recursive_call_f(self, greens_i, greens_r, greens_f,
+ reds_i, reds_r, reds_f):
+ fnptr, calldescr = self.get_portal_runner()
+ return self.cpu.bh_call_f(fnptr, calldescr,
+ greens_i + reds_i,
+ greens_r + reds_r,
+ greens_f + reds_f)
+ @arguments("self", "I", "R", "F", "I", "R", "F")
+ def bhimpl_recursive_call_v(self, greens_i, greens_r, greens_f,
+ reds_i, reds_r, reds_f):
+ fnptr, calldescr = self.get_portal_runner()
+ return self.cpu.bh_call_v(fnptr, calldescr,
+ greens_i + reds_i,
+ greens_r + reds_r,
+ greens_f + reds_f)
+
# ----------
# list operations
@@ -861,7 +900,7 @@
return cpu.bh_call_r(func, calldescr, None, args_r, None)
@arguments("cpu", "i", "d", "R")
def bhimpl_residual_call_r_v(cpu, func, calldescr, args_r):
- cpu.bh_call_v(func, calldescr, None, args_r, None)
+ return cpu.bh_call_v(func, calldescr, None, args_r, None)
@arguments("cpu", "i", "d", "I", "R", returns="i")
def bhimpl_residual_call_ir_i(cpu, func, calldescr, args_i, args_r):
@@ -871,7 +910,7 @@
return cpu.bh_call_r(func, calldescr, args_i, args_r, None)
@arguments("cpu", "i", "d", "I", "R")
def bhimpl_residual_call_ir_v(cpu, func, calldescr, args_i, args_r):
- cpu.bh_call_v(func, calldescr, args_i, args_r, None)
+ return cpu.bh_call_v(func, calldescr, args_i, args_r, None)
@arguments("cpu", "i", "d", "I", "R", "F", returns="i")
def bhimpl_residual_call_irf_i(cpu, func, calldescr,args_i,args_r,args_f):
@@ -884,7 +923,7 @@
return cpu.bh_call_f(func, calldescr, args_i, args_r, args_f)
@arguments("cpu", "i", "d", "I", "R", "F")
def bhimpl_residual_call_irf_v(cpu, func, calldescr,args_i,args_r,args_f):
- cpu.bh_call_v(func, calldescr, args_i, args_r, args_f)
+ return cpu.bh_call_v(func, calldescr, args_i, args_r, args_f)
@arguments("cpu", "j", "R", returns="i")
def bhimpl_inline_call_r_i(cpu, jitcode, args_r):
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/compile.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/compile.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/compile.py Thu May 27 16:27:07 2010
@@ -15,8 +15,10 @@
from pypy.jit.metainterp.typesystem import llhelper, oohelper
from pypy.jit.metainterp.optimizeutil import InvalidLoop
-class GiveUp(Exception):
- pass
+def giveup():
+ from pypy.jit.metainterp.pyjitpl import SwitchToBlackhole
+ from pypy.jit.metainterp.jitprof import ABORT_BRIDGE
+ raise SwitchToBlackhole(ABORT_BRIDGE)
def show_loop(metainterp_sd, loop=None, error=None):
# debugging
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/optimizeopt.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/optimizeopt.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/optimizeopt.py Thu May 27 16:27:07 2010
@@ -573,7 +573,7 @@
modifier = resume.ResumeDataVirtualAdder(descr, self.resumedata_memo)
newboxes = modifier.finish(self.values, pendingfields)
if len(newboxes) > self.metainterp_sd.options.failargs_limit: # XXX be careful here
- raise compile.GiveUp
+ compile.giveup()
descr.store_final_boxes(op, newboxes)
#
if op.opnum == rop.GUARD_VALUE:
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py Thu May 27 16:27:07 2010
@@ -19,7 +19,6 @@
from pypy.rlib.rarithmetic import intmask
from pypy.rlib.objectmodel import specialize
from pypy.rlib.jit import DEBUG_OFF, DEBUG_PROFILE, DEBUG_STEPS, DEBUG_DETAILED
-from pypy.jit.metainterp.compile import GiveUp
from pypy.jit.codewriter.jitcode import JitCode, SwitchDictDescr
# ____________________________________________________________
@@ -648,40 +647,46 @@
return self.execute_varargs(rop.CALL_LOOPINVARIANT, varargs, calldescr,
exc=True)
- @FixME #arguments("orgpc", "descr", "varargs")
- def opimpl_recursive_call(self, pc, calldescr, varargs):
- warmrunnerstate = self.metainterp.staticdata.state
- token = None
- if not self.metainterp.is_blackholing() and warmrunnerstate.inlining:
- num_green_args = self.metainterp.staticdata.num_green_args
- portal_code = self.metainterp.staticdata.portal_code
- greenkey = varargs[1:num_green_args + 1]
- if warmrunnerstate.can_inline_callable(greenkey):
- return self.perform_call(portal_code, varargs[1:], greenkey)
- token = warmrunnerstate.get_assembler_token(greenkey)
- call_position = 0
- if token is not None:
- call_position = len(self.metainterp.history.operations)
- # verify that we have all green args, needed to make sure
- # that assembler that we call is still correct
- greenargs = varargs[1:num_green_args + 1]
- self.verify_green_args(greenargs)
- res = self.do_residual_call(varargs, descr=calldescr, exc=True)
- if not self.metainterp.is_blackholing() and token is not None:
- # XXX fix the call position, <UGLY!>
- found = False
- while True:
- op = self.metainterp.history.operations[call_position]
- if op.opnum == rop.CALL or op.opnum == rop.CALL_MAY_FORCE:
- found = True
- break
- call_position += 1
- assert found
- # </UGLY!>
- # this will substitute the residual call with assembler call
- self.metainterp.direct_assembler_call(pc, varargs, token,
- call_position)
- return res
+ @arguments("boxes3", "boxes3")
+ def _opimpl_recursive_call(self, greenboxes, redboxes):
+ allboxes = greenboxes + redboxes
+ metainterp_sd = self.metainterp.staticdata
+ portal_code = metainterp_sd.portal_code
+## warmrunnerstate = metainterp_sd.state
+## token = None
+## if not self.is_blackholing() and warmrunnerstate.inlining:
+## if warmrunnerstate.can_inline_callable(greenboxes):
+## return self.metainterp.perform_call(portal_code, allboxes,
+## greenkey=greenboxes)
+## token = warmrunnerstate.get_assembler_token(greenboxes)
+## call_position = 0
+## if token is not None:
+## call_position = len(self.history.operations)
+## # verify that we have all green args, needed to make sure
+## # that assembler that we call is still correct
+## self.verify_green_args(greenboxes)
+ #
+ k = llmemory.cast_ptr_to_adr(metainterp_sd._portal_runner_ptr)
+ funcbox = ConstInt(llmemory.cast_adr_to_int(k))
+ resbox = self.do_residual_call(funcbox, portal_code.calldescr,
+ allboxes)
+ #
+## if token is not None:
+## # XXX fix the call position, <UGLY!>
+## while True:
+## op = self.history.operations[call_position]
+## if op.opnum == rop.CALL or op.opnum == rop.CALL_MAY_FORCE:
+## break
+## call_position += 1
+## # </UGLY!>
+## # this will substitute the residual call with assembler call
+## self.direct_assembler_call(boxes, token, call_position)
+ return resbox
+
+ opimpl_recursive_call_i = _opimpl_recursive_call
+ opimpl_recursive_call_r = _opimpl_recursive_call
+ opimpl_recursive_call_f = _opimpl_recursive_call
+ opimpl_recursive_call_v = _opimpl_recursive_call
@FixME #arguments("orgpc", "methdescr", "varargs")
def opimpl_oosend(self, pc, methdescr, varargs):
@@ -767,9 +772,15 @@
raise CannotInlineCanEnterJit()
self.metainterp.seen_can_enter_jit = True
+ def verify_green_args(self, varargs):
+ num_green_args = self.metainterp.staticdata.num_green_args
+ assert len(varargs) == num_green_args
+ for i in range(num_green_args):
+ assert isinstance(varargs[i], Const)
+
@arguments("orgpc", "boxes3", "boxes3")
def opimpl_jit_merge_point(self, orgpc, greenboxes, redboxes):
- self.metainterp.verify_green_args(greenboxes)
+ self.verify_green_args(greenboxes)
# xxx we may disable the following line in some context later
self.debug_merge_point(greenboxes)
if self.metainterp.seen_can_enter_jit:
@@ -1225,25 +1236,13 @@
def is_blackholing(self):
return False # XXX get rid of this method
- def perform_call(self, jitcode, boxes):
+ def perform_call(self, jitcode, boxes, greenkey=None):
# causes the metainterp to enter the given subfunction
# with a special case for recursive portal calls
- if jitcode is self.staticdata.portal_code:
- return self.perform_recursive_call_to_portal(boxes)
- else:
- self._perform_call(jitcode, boxes)
- # ^^^ always raises
-
- def _perform_call(self, jitcode, boxes, greenkey=None):
f = self.newframe(jitcode, greenkey)
f.setup_call(boxes)
raise ChangeFrame
- def verify_green_args(self, varargs):
- num_green_args = self.staticdata.num_green_args
- for i in range(num_green_args):
- assert isinstance(varargs[i], Const)
-
def newframe(self, jitcode, greenkey=None):
if jitcode is self.staticdata.portal_code:
self.in_recursion += 1
@@ -1279,8 +1278,8 @@
else:
try:
self.compile_done_with_this_frame(resultbox)
- except GiveUp:
- self.aborted_tracing(ABORT_BRIDGE)
+ except SwitchToBlackhole, stb:
+ self.aborted_tracing(stb.reason)
sd = self.staticdata
if sd.result_type == 'void':
assert resultbox is None
@@ -1320,8 +1319,8 @@
self.popframe()
try:
self.compile_exit_frame_with_exception(excvaluebox)
- except GiveUp:
- self.aborted_tracing(ABORT_BRIDGE)
+ except SwitchToBlackhole, stb:
+ self.aborted_tracing(stb.reason)
raise self.staticdata.ExitFrameWithExceptionRef(self.cpu, excvaluebox.getref_base())
def check_recursion_invariant(self):
@@ -2004,40 +2003,6 @@
max_key = key
return max_key
- def perform_recursive_call_to_portal(self, boxes):
- warmrunnerstate = self.staticdata.state
- portal_code = self.staticdata.portal_code
- token = None
- if not self.is_blackholing() and warmrunnerstate.inlining:
- num_green_args = self.staticdata.num_green_args
- greenkey = boxes[:num_green_args]
- if warmrunnerstate.can_inline_callable(greenkey):
- return self._perform_call(portal_code, boxes, greenkey)
- token = warmrunnerstate.get_assembler_token(greenkey)
- call_position = 0
- if token is not None:
- call_position = len(self.history.operations)
- # verify that we have all green args, needed to make sure
- # that assembler that we call is still correct
- self.verify_green_args(boxes)
- #
- k = llmemory.cast_ptr_to_adr(self.staticdata._portal_runner_ptr)
- funcbox = ConstInt(llmemory.cast_adr_to_int(k))
- frame = self.framestack[-1]
- resbox = frame.do_residual_call(funcbox, portal_code.calldescr, boxes)
- #
- if token is not None:
- # XXX fix the call position, <UGLY!>
- while True:
- op = self.history.operations[call_position]
- if op.opnum == rop.CALL or op.opnum == rop.CALL_MAY_FORCE:
- break
- call_position += 1
- # </UGLY!>
- # this will substitute the residual call with assembler call
- self.direct_assembler_call(boxes, token, call_position)
- return resbox
-
def direct_assembler_call(self, boxes, token, call_position):
""" Generate a direct call to assembler for portal entry point.
"""
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_recursive.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_recursive.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_recursive.py Thu May 27 16:27:07 2010
@@ -137,6 +137,7 @@
return interpret
+ @py.test.mark.xfail()
def test_inline(self):
code = "021"
subcode = "00"
@@ -162,6 +163,7 @@
inline=True) == 42
self.check_loops(call_may_force = 1, call = 0)
+ @py.test.mark.xfail()
def test_inline_faulty_can_inline(self):
code = "021"
subcode = "301"
@@ -179,12 +181,12 @@
def test_guard_failure_in_inlined_function(self):
from pypy.rpython.annlowlevel import hlstr
- def p(code, pc):
+ def p(pc, code):
code = hlstr(code)
return "%s %d %s" % (code, pc, code[pc])
- def c(code, pc):
+ def c(pc, code):
return "l" not in hlstr(code)
- myjitdriver = JitDriver(greens=['code', 'pc'], reds=['n'],
+ myjitdriver = JitDriver(greens=['pc', 'code'], reds=['n'],
get_printable_location=p, can_inline=c)
def f(code, n):
pc = 0
@@ -216,12 +218,12 @@
def test_guard_failure_and_then_exception_in_inlined_function(self):
from pypy.rpython.annlowlevel import hlstr
- def p(code, pc):
+ def p(pc, code):
code = hlstr(code)
return "%s %d %s" % (code, pc, code[pc])
- def c(code, pc):
+ def c(pc, code):
return "l" not in hlstr(code)
- myjitdriver = JitDriver(greens=['code', 'pc'], reds=['n', 'flag'],
+ myjitdriver = JitDriver(greens=['pc', 'code'], reds=['n', 'flag'],
get_printable_location=p, can_inline=c)
def f(code, n):
pc = 0
@@ -260,12 +262,12 @@
def test_exception_in_inlined_function(self):
from pypy.rpython.annlowlevel import hlstr
- def p(code, pc):
+ def p(pc, code):
code = hlstr(code)
return "%s %d %s" % (code, pc, code[pc])
- def c(code, pc):
+ def c(pc, code):
return "l" not in hlstr(code)
- myjitdriver = JitDriver(greens=['code', 'pc'], reds=['n'],
+ myjitdriver = JitDriver(greens=['pc', 'code'], reds=['n'],
get_printable_location=p, can_inline=c)
class Exc(Exception):
@@ -306,12 +308,12 @@
# it fails, it is very delicate in terms of parameters,
# bridge/loop creation order
from pypy.rpython.annlowlevel import hlstr
- def p(code, pc):
+ def p(pc, code):
code = hlstr(code)
return "%s %d %s" % (code, pc, code[pc])
- def c(code, pc):
+ def c(pc, code):
return "l" not in hlstr(code)
- myjitdriver = JitDriver(greens=['code', 'pc'], reds=['n'],
+ myjitdriver = JitDriver(greens=['pc', 'code'], reds=['n'],
get_printable_location=p, can_inline=c)
def f(code, n):
@@ -397,7 +399,7 @@
def test_max_failure_args(self):
FAILARGS_LIMIT = 10
- jitdriver = JitDriver(greens = [], reds = ['o', 'i', 'n'])
+ jitdriver = JitDriver(greens = [], reds = ['i', 'n', 'o'])
class A(object):
def __init__(self, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9):
@@ -430,7 +432,7 @@
def test_max_failure_args_exc(self):
FAILARGS_LIMIT = 10
- jitdriver = JitDriver(greens = [], reds = ['o', 'i', 'n'])
+ jitdriver = JitDriver(greens = [], reds = ['i', 'n', 'o'])
class A(object):
def __init__(self, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9):
@@ -469,6 +471,7 @@
assert not res
self.check_aborted_count(5)
+ @py.test.mark.xfail()
def test_set_param_inlining(self):
myjitdriver = JitDriver(greens=[], reds=['n', 'recurse'])
def loop(n, recurse=False):
@@ -496,12 +499,12 @@
self.check_loops(call_may_force=0, call=0)
def test_trace_from_start(self):
- def p(code, pc):
+ def p(pc, code):
code = hlstr(code)
return "%s %d %s" % (code, pc, code[pc])
- def c(code, pc):
+ def c(pc, code):
return "l" not in hlstr(code)
- myjitdriver = JitDriver(greens=['code', 'pc'], reds=['n'],
+ myjitdriver = JitDriver(greens=['pc', 'code'], reds=['n'],
get_printable_location=p, can_inline=c)
def f(code, n):
@@ -535,13 +538,14 @@
self.check_tree_loop_count(3)
self.check_history(int_add=1)
+ @py.test.mark.xfail()
def test_dont_inline_huge_stuff(self):
- def p(code, pc):
+ def p(pc, code):
code = hlstr(code)
return "%s %d %s" % (code, pc, code[pc])
- def c(code, pc):
+ def c(pc, code):
return "l" not in hlstr(code)
- myjitdriver = JitDriver(greens=['code', 'pc'], reds=['n'],
+ myjitdriver = JitDriver(greens=['pc', 'code'], reds=['n'],
get_printable_location=p, can_inline=c)
def f(code, n):
@@ -579,6 +583,7 @@
self.check_history(call_assembler=1, call=0)
self.check_tree_loop_count(3)
+ @py.test.mark.xfail()
def test_directly_call_assembler(self):
driver = JitDriver(greens = ['codeno'], reds = ['i'],
get_printable_location = lambda codeno : str(codeno),
@@ -616,6 +621,7 @@
self.check_history(call_assembler=0, call_may_force=1)
self.check_enter_count_at_most(1)
+ @py.test.mark.xfail()
def test_directly_call_assembler_return(self):
driver = JitDriver(greens = ['codeno'], reds = ['i', 'k'],
get_printable_location = lambda codeno : str(codeno),
@@ -635,6 +641,7 @@
self.meta_interp(portal, [2], inline=True)
self.check_history(call_assembler=1)
+ @py.test.mark.xfail()
def test_directly_call_assembler_raise(self):
class MyException(Exception):
@@ -694,7 +701,7 @@
class Frame(object):
_virtualizable2_ = ['thing']
- driver = JitDriver(greens = ['codeno'], reds = ['frame', 'i'],
+ driver = JitDriver(greens = ['codeno'], reds = ['i', 'frame'],
virtualizables = ['frame'],
get_printable_location = lambda codeno : str(codeno),
can_inline = lambda codeno : False)
@@ -730,7 +737,7 @@
class Frame(object):
_virtualizable2_ = ['thing']
- driver = JitDriver(greens = ['codeno'], reds = ['frame', 'i'],
+ driver = JitDriver(greens = ['codeno'], reds = ['i', 'frame'],
virtualizables = ['frame'],
get_printable_location = lambda codeno : str(codeno),
can_inline = lambda codeno : False)
@@ -771,7 +778,7 @@
assert res == main(0)
def test_directly_call_assembler_virtualizable_with_array(self):
- myjitdriver = JitDriver(greens = ['codeno'], reds = ['n', 'frame', 'x'],
+ myjitdriver = JitDriver(greens = ['codeno'], reds = ['n', 'x', 'frame'],
virtualizables = ['frame'],
can_inline = lambda codeno : False)
@@ -817,7 +824,7 @@
class Frame(object):
_virtualizable2_ = ['thing']
- driver = JitDriver(greens = ['codeno'], reds = ['frame', 'i'],
+ driver = JitDriver(greens = ['codeno'], reds = ['i', 'frame'],
virtualizables = ['frame'],
get_printable_location = lambda codeno : str(codeno),
can_inline = lambda codeno : False)
@@ -860,6 +867,7 @@
policy=StopAtXPolicy(change))
assert res == main(0)
+ @py.test.mark.xfail()
def test_assembler_call_red_args(self):
driver = JitDriver(greens = ['codeno'], reds = ['i', 'k'],
get_printable_location = lambda codeno : str(codeno),
More information about the Pypy-commit
mailing list