[pypy-svn] r74508 - in pypy/branch/blackhole-improvement/pypy/jit: backend/llgraph codewriter codewriter/test metainterp
arigo at codespeak.net
arigo at codespeak.net
Thu May 13 16:28:37 CEST 2010
Author: arigo
Date: Thu May 13 16:28:35 2010
New Revision: 74508
Modified:
pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/llimpl.py
pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/runner.py
pypy/branch/blackhole-improvement/pypy/jit/codewriter/flatten.py
pypy/branch/blackhole-improvement/pypy/jit/codewriter/jtransform.py
pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_flatten.py
pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_jtransform.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py
Log:
Progress.
Modified: pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/llimpl.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/llimpl.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/llimpl.py Thu May 13 16:28:35 2010
@@ -399,10 +399,9 @@
class Frame(object):
OPHANDLERS = [None] * (rop._LAST+1)
- def __init__(self, memocast, cpu):
+ def __init__(self, cpu):
self.verbose = False
self.cpu = cpu
- self.memocast = memocast
self.opindex = 1
self._forced = False
self._may_force = -1
@@ -529,7 +528,7 @@
return res
def as_int(self, x):
- return cast_to_int(x, self.memocast)
+ return cast_to_int(x)
def as_ptr(self, x):
return cast_to_ptr(x)
@@ -553,34 +552,32 @@
try:
op = getattr(cls, 'op_' + opname.lower()) # op_guard_true etc.
except AttributeError:
- name = 'do_' + opname.lower()
try:
- impl = globals()[name] # do_arraylen_gc etc.
- def op(self, descr, *args):
- return impl(descr, *args)
- #
+ impl = globals()['do_' + opname.lower()] # do_arraylen_gc etc.
+ op = staticmethod(impl)
except KeyError:
- from pypy.jit.backend.llgraph import llimpl
- impl = getattr(executor, name) # do_int_add etc.
- def _op_default_implementation(self, descr, *args):
- # for all operations implemented in execute.py
- boxedargs = []
- for x in args:
- if type(x) is int:
- boxedargs.append(BoxInt(x))
- elif type(x) is float:
- boxedargs.append(BoxFloat(x))
- elif isinstance(ootype.typeOf(x), ootype.OOType):
- boxedargs.append(BoxObj(ootype.cast_to_object(x)))
- else:
- boxedargs.append(BoxPtr(x))
- # xxx this passes the 'llimpl' module as the CPU argument
- resbox = impl(llimpl, *boxedargs)
- return getattr(resbox, 'value', None)
- op = _op_default_implementation
- #
+ op = cls._make_impl_from_blackhole_interp(opname)
cls.OPHANDLERS[opnum] = op
+ @classmethod
+ def _make_impl_from_blackhole_interp(cls, opname):
+ from pypy.jit.metainterp.blackhole import BlackholeInterpreter
+ name = 'bhimpl_' + opname.lower()
+ func = BlackholeInterpreter.__dict__[name]
+ for argtype in func.argtypes:
+ assert argtype in ('i', 'r', 'f')
+ #
+ def _op_default_implementation(self, descr, *args):
+ # for all operations implemented in the blackhole interpreter
+ return func(*args)
+ #
+ return _op_default_implementation
+
+ def op_debug_merge_point(self, _, value):
+ from pypy.jit.metainterp.warmspot import get_stats
+ loc = ConstPtr(value)._get_str()
+ get_stats().add_merge_point_location(loc)
+
def op_guard_true(self, _, value):
if not value:
raise GuardFailed
@@ -800,7 +797,7 @@
return do_new_array(arraydescr.ofs, count)
def op_cast_ptr_to_int(self, descr, ptr):
- return cast_to_int(ptr, self.memocast)
+ return cast_to_int(ptr)
def op_uint_xor(self, descr, arg1, arg2):
return arg1 ^ arg2
@@ -1012,11 +1009,11 @@
return x
-def new_frame(memocast, is_oo, cpu):
+def new_frame(is_oo, cpu):
if is_oo:
- frame = OOFrame(memocast, cpu)
+ frame = OOFrame(cpu)
else:
- frame = Frame(memocast, cpu)
+ frame = Frame(cpu)
return _to_opaque(frame)
_future_values = []
Modified: pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/runner.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/runner.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/runner.py Thu May 13 16:28:35 2010
@@ -209,7 +209,7 @@
def _execute_token(self, loop_token):
compiled_version = loop_token._llgraph_compiled_version
- frame = llimpl.new_frame(self.memo_cast, self.is_oo, self)
+ frame = llimpl.new_frame(self.is_oo, self)
# setup the frame
llimpl.frame_clear(frame, compiled_version)
# run the loop
@@ -869,10 +869,3 @@
def __repr__(self):
return '<FieldDescr %r>' % self.fieldname
-
-
-# ____________________________________________________________
-
-import pypy.jit.metainterp.executor
-pypy.jit.metainterp.executor.make_execute_list(LLtypeCPU)
-##pypy.jit.metainterp.executor.make_execute_list(OOtypeCPU)
Modified: pypy/branch/blackhole-improvement/pypy/jit/codewriter/flatten.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/codewriter/flatten.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/codewriter/flatten.py Thu May 13 16:28:35 2010
@@ -43,6 +43,8 @@
return '%s%s' % (self.kind[0], self.content)
def __iter__(self):
return iter(self.content)
+ def __nonzero__(self):
+ return bool(self.content)
class IndirectCallTargets(object):
def __init__(self, lst):
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 13 16:28:35 2010
@@ -17,10 +17,6 @@
t.transform(graph, portal)
-class NoOp(Exception):
- pass
-
-
class Transformer(object):
def __init__(self, cpu=None, callcontrol=None):
@@ -36,36 +32,40 @@
def optimize_block(self, block):
if block.operations == ():
return
- rename = {}
+ renamings = {}
newoperations = []
- if block.exitswitch == c_last_exception:
- op_raising_exception = block.operations[-1]
- else:
- op_raising_exception = Ellipsis
+ #
for op in block.operations:
- try:
- op1 = self.rewrite_operation(op)
- except NoOp:
- if op.result is not None:
- rename[op.result] = rename.get(op.args[0], op.args[0])
- if op is op_raising_exception:
- self.killed_exception_raising_operation(block)
- else:
+ oplist = self.rewrite_operation(op)
+ #
+ count_before_last_operation = len(newoperations)
+ if not isinstance(oplist, list):
+ oplist = [oplist]
+ for op1 in oplist:
if isinstance(op1, SpaceOperation):
- op2 = self.do_renaming(rename, op1)
- newoperations.append(op2)
+ newoperations.append(self._do_renaming(renamings, op1))
+ elif op1 is None:
+ # rewrite_operation() returns None to mean "has no real
+ # effect, the result should just be renamed to args[0]"
+ if op.result is not None:
+ renamings[op.result] = renamings.get(op.args[0],
+ op.args[0])
elif isinstance(op1, Constant):
- rename[op.result] = op1
+ renamings[op.result] = op1
else:
raise TypeError(repr(op1))
+ #
+ if block.exitswitch == c_last_exception:
+ if len(newoperations) == count_before_last_operation:
+ self._killed_exception_raising_operation(block)
block.operations = newoperations
- block.exitswitch = rename.get(block.exitswitch, block.exitswitch)
+ block.exitswitch = renamings.get(block.exitswitch, block.exitswitch)
self.follow_constant_exit(block)
self.optimize_goto_if_not(block)
for link in block.exits:
- self.do_renaming_on_link(rename, link)
+ self._do_renaming_on_link(renamings, link)
- def do_renaming(self, rename, op):
+ def _do_renaming(self, rename, op):
op = SpaceOperation(op.opname, op.args[:], op.result)
for i, v in enumerate(op.args):
if isinstance(v, Variable):
@@ -80,13 +80,13 @@
op.args[i] = ListOfKind(v.kind, newlst)
return op
- def do_renaming_on_link(self, rename, link):
+ def _do_renaming_on_link(self, rename, link):
for i, v in enumerate(link.args):
if isinstance(v, Variable):
if v in rename:
link.args[i] = rename[v]
- def killed_exception_raising_operation(self, block):
+ def _killed_exception_raising_operation(self, block):
assert block.exits[0].exitcase is None
del block.exits[1:]
block.exitswitch = None
@@ -140,21 +140,21 @@
try:
rewrite = _rewrite_ops[op.opname]
except KeyError:
- return op
+ return op # default: keep the operation unchanged
else:
return rewrite(self, op)
- def rewrite_op_same_as(self, op): raise NoOp
- def rewrite_op_cast_pointer(self, op): raise NoOp
- def rewrite_op_cast_primitive(self, op): raise NoOp
- def rewrite_op_cast_bool_to_int(self, op): raise NoOp
- def rewrite_op_cast_bool_to_uint(self, op): raise NoOp
- def rewrite_op_cast_char_to_int(self, op): raise NoOp
- def rewrite_op_cast_unichar_to_int(self, op): raise NoOp
- def rewrite_op_cast_int_to_char(self, op): raise NoOp
- def rewrite_op_cast_int_to_unichar(self, op): raise NoOp
- def rewrite_op_cast_int_to_uint(self, op): raise NoOp
- def rewrite_op_cast_uint_to_int(self, op): raise NoOp
+ def rewrite_op_same_as(self, op): pass
+ def rewrite_op_cast_pointer(self, op): pass
+ def rewrite_op_cast_primitive(self, op): pass
+ def rewrite_op_cast_bool_to_int(self, op): pass
+ def rewrite_op_cast_bool_to_uint(self, op): pass
+ def rewrite_op_cast_char_to_int(self, op): pass
+ def rewrite_op_cast_unichar_to_int(self, op): pass
+ def rewrite_op_cast_int_to_char(self, op): pass
+ def rewrite_op_cast_int_to_unichar(self, op): pass
+ def rewrite_op_cast_int_to_uint(self, op): pass
+ def rewrite_op_cast_uint_to_int(self, op): pass
def _rewrite_symmetric(self, op):
"""Rewrite 'c1+v2' into 'v2+c1' in an attempt to avoid generating
@@ -211,22 +211,28 @@
"""Turn 'i0 = direct_call(fn, i1, i2, ref1, ref2)'
into 'i0 = xxx_call_ir_i(fn, descr, [i1,i2], [ref1,ref2])'.
The name is one of '{residual,direct}_call_{r,ir,irf}_{i,r,f,v}'."""
- args_i = []
- args_r = []
- args_f = []
- for v in op.args[1:]:
- self.add_in_correct_list(v, args_i, args_r, args_f)
+ lst_i, lst_r, lst_f = self.make_three_lists(op.args[1:])
reskind = getkind(op.result.concretetype)[0]
- if args_f or reskind == 'f': kinds = 'irf'
- elif args_i: kinds = 'ir'
- else: kinds = 'r'
+ if lst_f or reskind == 'f': kinds = 'irf'
+ elif lst_i: kinds = 'ir'
+ else: kinds = 'r'
sublists = []
- if 'i' in kinds: sublists.append(ListOfKind('int', args_i))
- if 'r' in kinds: sublists.append(ListOfKind('ref', args_r))
- if 'f' in kinds: sublists.append(ListOfKind('float', args_f))
+ if 'i' in kinds: sublists.append(lst_i)
+ if 'r' in kinds: sublists.append(lst_r)
+ if 'f' in kinds: sublists.append(lst_f)
return SpaceOperation('%s_%s_%s' % (namebase, kinds, reskind),
initialargs + sublists, op.result)
+ def make_three_lists(self, vars):
+ args_i = []
+ args_r = []
+ args_f = []
+ for v in vars:
+ self.add_in_correct_list(v, args_i, args_r, args_f)
+ return [ListOfKind('int', args_i),
+ ListOfKind('ref', args_r),
+ ListOfKind('float', args_f)]
+
def add_in_correct_list(self, v, lst_i, lst_r, lst_f):
kind = getkind(v.concretetype)
if kind == 'void': return
@@ -305,11 +311,13 @@
kind = getkind(op.args[0].concretetype)
# note: the 'G_' prefix tells that the operation might generate
# a guard in pyjitpl (see liveness.py)
- return SpaceOperation('G_%s_guard_value' % kind,
- [op.args[0]], op.result)
+ op = SpaceOperation('G_%s_guard_value' % kind,
+ [op.args[0]], None)
+ # this special return value forces op.result to be considered
+ # equal to op.args[0]
+ return [op, None]
else:
log.WARNING('ignoring hint %r at %r' % (hints, self.graph))
- raise NoOp
def rewrite_op_malloc_varsize(self, op):
assert op.args[1].value == {'flavor': 'gc'}
@@ -355,7 +363,7 @@
[v_inst, c_fieldname] = op.args
RESULT = op.result.concretetype
if RESULT is lltype.Void:
- raise NoOp
+ return
# check for virtualizable
#try:
# if self.is_virtualizable_getset(op):
@@ -393,12 +401,12 @@
def rewrite_op_setfield(self, op):
if self.is_typeptr_getset(op):
# ignore the operation completely -- instead, it's done by 'new'
- raise NoOp
+ return
# turn the flow graph 'setfield' operation into our own version
[v_inst, c_fieldname, v_value] = op.args
RESULT = v_value.concretetype
if RESULT is lltype.Void:
- raise NoOp
+ return
# check for virtualizable
#if self.is_virtualizable_getset(op):
# vinfo = self.codewriter.metainterp_sd.virtualizable_info
@@ -530,8 +538,6 @@
def rewrite_op_cast_ptr_to_int(self, op):
if self._is_gc(op.args[0]):
return op
- else:
- raise NoOp
# ----------
# Renames, from the _old opname to the _new one.
@@ -609,17 +615,27 @@
return op
def rewrite_op_jit_marker(self, op):
- opname = op.args[0].value
jitdriver = op.args[1].value
self.callcontrol.found_jitdriver(jitdriver)
- args_i = []
- args_r = []
- args_f = []
- for v in op.args[2:]:
- self.add_in_correct_list(v, args_i, args_r, args_f)
- return SpaceOperation(opname, [ListOfKind('int', args_i),
- ListOfKind('ref', args_r),
- ListOfKind('float', args_f)], op.result)
+ key = op.args[0].value
+ return getattr(self, 'handle_jit_marker__%s' % key)(op, jitdriver)
+
+ def handle_jit_marker__jit_merge_point(self, op, jitdriver):
+ assert self.portal, "jit_merge_point in non-main graph!"
+ ops = []
+ num_green_args = len(jitdriver.greens)
+ for v in op.args[2:2+num_green_args]:
+ if isinstance(v, Variable) and v.concretetype is not lltype.Void:
+ kind = getkind(v.concretetype)
+ ops.append(SpaceOperation('G_%s_guard_value' % kind,
+ [v], None))
+ args = (self.make_three_lists(op.args[2:2+num_green_args]) +
+ self.make_three_lists(op.args[2+num_green_args:]))
+ ops.append(SpaceOperation('jit_merge_point', args, None))
+ return ops
+
+ def handle_jit_marker__can_enter_jit(self, op, jitdriver):
+ return SpaceOperation('can_enter_jit', [], None)
# ____________________________________________________________
Modified: pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_flatten.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_flatten.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_flatten.py Thu May 13 16:28:35 2010
@@ -457,7 +457,8 @@
myjitdriver.jit_merge_point(x=x, y=y)
myjitdriver.can_enter_jit(x=y, y=x)
self.encoding_test(f, [4, 5], """
- jit_merge_point I[%i0, %i1], R[], F[]
- can_enter_jit I[%i1, %i0], R[], F[]
+ G_int_guard_value %i0
+ jit_merge_point I[%i0], R[], F[], I[%i1], R[], F[]
+ can_enter_jit
void_return
""", transform=True)
Modified: pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_jtransform.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_jtransform.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/codewriter/test/test_jtransform.py Thu May 13 16:28:35 2010
@@ -516,3 +516,34 @@
assert op1.opname == 'unicodesetitem'
assert op1.args == [v, v_index, v_newchr]
assert op1.result == v_void
+
+def test_promote_1():
+ v1 = varoftype(lltype.Signed)
+ v2 = varoftype(lltype.Signed)
+ op = SpaceOperation('hint',
+ [v1, Constant({'promote': True}, lltype.Void)],
+ v2)
+ oplist = Transformer().rewrite_operation(op)
+ assert len(oplist) == 2
+ assert oplist[1] is None
+ assert oplist[0].opname == 'G_int_guard_value'
+ assert oplist[0].args == [v1]
+ assert oplist[0].result is None
+
+def test_promote_2():
+ v1 = varoftype(lltype.Signed)
+ v2 = varoftype(lltype.Signed)
+ op = SpaceOperation('hint',
+ [v1, Constant({'promote': True}, lltype.Void)],
+ v2)
+ returnblock = Block([varoftype(lltype.Signed)])
+ returnblock.operations = ()
+ block = Block([v1])
+ block.operations = [op]
+ block.closeblock(Link([v2], returnblock))
+ Transformer().optimize_block(block)
+ assert len(block.operations) == 1
+ assert block.operations[0].opname == 'G_int_guard_value'
+ assert block.operations[0].args == [v1]
+ assert block.operations[0].result is None
+ assert block.exits[0].args == [v1]
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 13 16:28:35 2010
@@ -475,9 +475,15 @@
def bhimpl_float_copy(a):
return a
- bhimpl_int_guard_value = bhimpl_int_copy
- bhimpl_ref_guard_value = bhimpl_ref_copy
- bhimpl_float_guard_value = bhimpl_float_copy
+ @arguments("i")
+ def bhimpl_int_guard_value(a):
+ pass
+ @arguments("r")
+ def bhimpl_ref_guard_value(a):
+ pass
+ @arguments("f")
+ def bhimpl_float_guard_value(a):
+ pass
@arguments("self", "i")
def bhimpl_int_push(self, a):
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py Thu May 13 16:28:35 2010
@@ -203,8 +203,7 @@
# ____________________________________________________________
-def make_execute_list(cpuclass):
- from pypy.jit.backend.model import AbstractCPU
+def _make_execute_list():
if 0: # enable this to trace calls to do_xxx
def wrap(fn):
def myfn(*args):
@@ -259,7 +258,7 @@
execute[value] = func
continue
print "XXX warning: missing", key
- cpuclass._execute_by_num_args = execute_by_num_args
+ return execute_by_num_args
def make_execute_function_with_boxes(name, func):
# Make a wrapper for 'func'. The func is a simple bhimpl_xxx function
@@ -300,17 +299,19 @@
do.func_name = 'do_' + name
return do
-def get_execute_funclist(cpu, num_args):
+def get_execute_funclist(num_args):
# workaround, similar to the next one
- return cpu._execute_by_num_args[num_args]
+ return EXECUTE_BY_NUM_ARGS[num_args]
get_execute_funclist._annspecialcase_ = 'specialize:memo'
-def get_execute_function(cpu, opnum, num_args):
+def get_execute_function(opnum, num_args):
# workaround for an annotation limitation: putting this code in
# a specialize:memo function makes sure the following line is
# constant-folded away. Only works if opnum and num_args are
# constants, of course.
- return cpu._execute_by_num_args[num_args][opnum]
+ func = EXECUTE_BY_NUM_ARGS[num_args][opnum]
+ assert func is not None, "EXECUTE_BY_NUM_ARGS[%s][%s]" % (num_args, opnum)
+ return func
get_execute_function._annspecialcase_ = 'specialize:memo'
def has_descr(opnum):
@@ -326,8 +327,7 @@
argboxes = argboxes + (descr,)
else:
assert descr is None
- func = get_execute_function(metainterp.cpu, opnum, len(argboxes))
- assert func is not None
+ func = get_execute_function(opnum, len(argboxes))
return func(metainterp, *argboxes) # note that the 'argboxes' tuple
# optionally ends with the descr
execute._annspecialcase_ = 'specialize:arg(1)'
@@ -335,41 +335,45 @@
def execute_varargs(metainterp, opnum, argboxes, descr):
# only for opnums with a variable arity (calls, typically)
check_descr(descr)
- func = get_execute_function(metainterp.cpu, opnum, -1)
- assert func is not None
+ func = get_execute_function(opnum, -1)
return func(metainterp, argboxes, descr)
execute_varargs._annspecialcase_ = 'specialize:arg(1)'
-def execute_nonspec(cpu, opnum, argboxes, descr=None):
+def execute_nonspec(metainterp, opnum, argboxes, descr=None):
+ assert metainterp.__class__.__name__ == 'MetaInterp' # XXX kill me
arity = resoperation.oparity[opnum]
assert arity == -1 or len(argboxes) == arity
if resoperation.opwithdescr[opnum]:
check_descr(descr)
if arity == -1:
- func = get_execute_funclist(cpu, -1)[opnum]
- return func(cpu, argboxes, descr)
+ func = get_execute_funclist(-1)[opnum]
+ return func(metainterp, argboxes, descr)
if arity == 0:
- func = get_execute_funclist(cpu, 1)[opnum]
- return func(cpu, descr)
+ func = get_execute_funclist(1)[opnum]
+ return func(metainterp, descr)
if arity == 1:
- func = get_execute_funclist(cpu, 2)[opnum]
- return func(cpu, argboxes[0], descr)
+ func = get_execute_funclist(2)[opnum]
+ return func(metainterp, argboxes[0], descr)
if arity == 2:
- func = get_execute_funclist(cpu, 3)[opnum]
- return func(cpu, argboxes[0], argboxes[1], descr)
+ func = get_execute_funclist(3)[opnum]
+ return func(metainterp, argboxes[0], argboxes[1], descr)
if arity == 3:
- func = get_execute_funclist(cpu, 4)[opnum]
- return func(cpu, argboxes[0], argboxes[1], argboxes[2], descr)
+ func = get_execute_funclist(4)[opnum]
+ return func(metainterp, argboxes[0], argboxes[1], argboxes[2],
+ descr)
else:
assert descr is None
if arity == 1:
- func = get_execute_funclist(cpu, 1)[opnum]
- return func(cpu, argboxes[0])
+ func = get_execute_funclist(1)[opnum]
+ return func(metainterp, argboxes[0])
if arity == 2:
- func = get_execute_funclist(cpu, 2)[opnum]
- return func(cpu, argboxes[0], argboxes[1])
+ func = get_execute_funclist(2)[opnum]
+ return func(metainterp, argboxes[0], argboxes[1])
if arity == 3:
- func = get_execute_funclist(cpu, 3)[opnum]
- return func(cpu, argboxes[0], argboxes[1], argboxes[2])
+ func = get_execute_funclist(3)[opnum]
+ return func(metainterp, argboxes[0], argboxes[1], argboxes[2])
raise NotImplementedError
+
+
+EXECUTE_BY_NUM_ARGS = _make_execute_list()
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 13 16:28:35 2010
@@ -51,7 +51,7 @@
parent_resumedata_snapshot = None
parent_resumedata_frame_info_list = None
- env = property(lambda: xxx, lambda x: xxx) # no read/write!
+ env = property(lambda: xxx, lambda: xxx) # temporary: no read/write!
def __init__(self, metainterp):
self.metainterp = metainterp
@@ -771,19 +771,12 @@
self.execute_varargs(rop.OOSEND_PURE, boxes, descr=methdescr, exc=False)
@arguments("box")
- def opimpl_int_guard_value(self, box):
- return self.implement_guard_value(box)
+ def _opimpl_guard_value(self, box):
+ self.implement_guard_value(box)
- @XXX #arguments("orgpc", "int")
- def opimpl_guard_green(self, pc, boxindex):
- """Like guard_value, but overwrites the original box with the const.
- Used to prevent Boxes from showing up in the greenkey of some
- operations, like jit_merge_point. The in-place overwriting is
- convenient for jit_merge_point, which expects self.env to contain
- not more than the greens+reds described in the jitdriver."""
- box = self.env[boxindex]
- constbox = self.implement_guard_value(pc, box)
- self.env[boxindex] = constbox
+ opimpl_int_guard_value = _opimpl_guard_value
+ opimpl_ref_guard_value = _opimpl_guard_value
+ opimpl_float_guard_value = _opimpl_guard_value
@arguments("box")
def opimpl_guard_class(self, box):
@@ -831,39 +824,28 @@
else:
raise self.metainterp.staticdata.ContinueRunningNormally(varargs)
- @arguments("boxes3")
- def opimpl_can_enter_jit(self, boxes):
- xxx
- # Note: when running with a BlackHole history, this 'can_enter_jit'
- # may be completely skipped by the logic that replaces perform_call
- # with rop.CALL. But in that case, no-one will check the flag anyway,
- # so it's fine.
+ @arguments()
+ def opimpl_can_enter_jit(self):
if self.metainterp.in_recursion:
from pypy.jit.metainterp.warmspot import CannotInlineCanEnterJit
raise CannotInlineCanEnterJit()
self.metainterp.seen_can_enter_jit = True
- @arguments("boxes3")
- def opimpl_jit_merge_point(self, boxes):
- xxx
- if not self.metainterp.is_blackholing():
- self.verify_green_args(self.env)
- # xxx we may disable the following line in some context later
- self.debug_merge_point()
- if self.metainterp.seen_can_enter_jit:
- self.metainterp.seen_can_enter_jit = False
- try:
- self.metainterp.reached_can_enter_jit(self.env)
- except GiveUp:
- self.metainterp.switch_to_blackhole(ABORT_BRIDGE)
- if self.metainterp.is_blackholing():
- self.blackhole_reached_merge_point(self.env)
- return True
+ @arguments("boxes3", "boxes3")
+ def opimpl_jit_merge_point(self, greenboxes, redboxes):
+ 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:
+ self.metainterp.seen_can_enter_jit = False
+ try:
+ self.metainterp.reached_can_enter_jit(greenboxes, redboxes)
+ except GiveUp:
+ XXX
+ self.metainterp.switch_to_blackhole(ABORT_BRIDGE)
- def debug_merge_point(self):
+ def debug_merge_point(self, greenkey):
# debugging: produce a DEBUG_MERGE_POINT operation
- num_green_args = self.metainterp.staticdata.num_green_args
- greenkey = self.env[:num_green_args]
sd = self.metainterp.staticdata
loc = sd.state.get_location_str(greenkey)
debug_print(loc)
@@ -1583,9 +1565,8 @@
key.reset_counter_from_failure(self)
raise
- def remove_consts_and_duplicates(self, boxes, startindex, endindex,
- duplicates):
- for i in range(startindex, endindex):
+ def remove_consts_and_duplicates(self, boxes, endindex, duplicates):
+ for i in range(endindex):
box = boxes[i]
if isinstance(box, Const) or box in duplicates:
oldbox = box
@@ -1595,19 +1576,15 @@
else:
duplicates[box] = None
- def reached_can_enter_jit(self, live_arg_boxes):
- num_green_args = self.staticdata.num_green_args
+ def reached_can_enter_jit(self, greenboxes, redboxes):
duplicates = {}
- self.remove_consts_and_duplicates(live_arg_boxes,
- num_green_args,
- len(live_arg_boxes),
+ self.remove_consts_and_duplicates(redboxes, len(redboxes),
duplicates)
- live_arg_boxes = live_arg_boxes[:]
+ live_arg_boxes = greenboxes + redboxes
if self.staticdata.virtualizable_info is not None:
# we use ':-1' to remove the last item, which is the virtualizable
# itself
self.remove_consts_and_duplicates(self.virtualizable_boxes,
- 0,
len(self.virtualizable_boxes)-1,
duplicates)
live_arg_boxes += self.virtualizable_boxes[:-1]
@@ -2140,7 +2117,7 @@
self.pc = position + num_return_args
#
if not we_are_translated():
- print '\tjitcode:', name, list(args),
+ print '\tjitcode: %s(%s)' % (name, ', '.join(map(repr, args))),
try:
resultbox = unboundmethod(self, *args)
except Exception, e:
@@ -2150,7 +2127,7 @@
print
assert resultbox is None
else:
- print '->', resultbox
+ print '-> %r' % (resultbox,)
result_argcode = argcodes[next_argcode]
assert resultbox.type == {'i': history.INT,
'r': history.REF,
More information about the Pypy-commit
mailing list