[pypy-svn] r25215 - in pypy/branch/jit-timeshifter-refactoring/timeshifter: . test
arigo at codespeak.net
arigo at codespeak.net
Sat Apr 1 23:18:36 CEST 2006
Author: arigo
Date: Sat Apr 1 23:18:35 2006
New Revision: 25215
Modified:
pypy/branch/jit-timeshifter-refactoring/timeshifter/rtimeshift.py
pypy/branch/jit-timeshifter-refactoring/timeshifter/rtyper.py
pypy/branch/jit-timeshifter-refactoring/timeshifter/rvalue.py
pypy/branch/jit-timeshifter-refactoring/timeshifter/test/test_timeshift.py
pypy/branch/jit-timeshifter-refactoring/timeshifter/timeshift.py
Log:
(arre, pedronis, arigo) Intermediate check-in.
Modified: pypy/branch/jit-timeshifter-refactoring/timeshifter/rtimeshift.py
==============================================================================
--- pypy/branch/jit-timeshifter-refactoring/timeshifter/rtimeshift.py (original)
+++ pypy/branch/jit-timeshifter-refactoring/timeshifter/rtimeshift.py Sat Apr 1 23:18:35 2006
@@ -1,6 +1,7 @@
import operator, weakref
from pypy.rpython.lltypesystem import lltype, lloperation, llmemory
from pypy.rpython import rgenop
+from pypy.jit.timeshifter import rvalue
FOLDABLE_OPS = dict.fromkeys(lloperation.enum_foldable_ops())
@@ -19,12 +20,12 @@
"ll_length": ll_fixed_length
}))
-def make_types_const(TYPES):
- n = len(TYPES)
- l = lltype.malloc(VARLIST.TO, n)
- for i in range(n):
- l[i] = rgenop.constTYPE(TYPES[i])
- return l
+##def make_types_const(TYPES):
+## n = len(TYPES)
+## l = lltype.malloc(VARLIST.TO, n)
+## for i in range(n):
+## l[i] = rgenop.constTYPE(TYPES[i])
+## return l
##class RedBox(object):
@@ -454,6 +455,8 @@
self.nb_args = len(ARGS)
self.ARGS = ARGS
self.RESULT = RESULT
+ self.gv_RESULT = rgenop.constTYPE(RESULT)
+ self.redboxcls = rvalue.ll_redboxcls(RESULT)
self.canfold = opname in FOLDABLE_OPS
def __getattr__(self, name): # .ARGx -> .ARGS[x]
@@ -484,34 +487,33 @@
ARG0 = opdesc.ARG0
RESULT = opdesc.RESULT
opname = opdesc.name
- if opdesc.canfold and isinstance(argbox, ConstRedBox):
- arg = argbox.ll_getvalue(ARG0)
+ if opdesc.canfold and argbox.is_constant():
+ arg = rvalue.ll_getvalue(argbox, ARG0)
res = opdesc.llop(RESULT, arg)
- return ConstRedBox.ll_fromvalue(res)
+ return rvalue.ll_fromvalue(res)
op_args = lltype.malloc(VARLIST.TO, 1)
op_args[0] = argbox.getgenvar(jitstate)
genvar = rgenop.genop(jitstate.curblock, opdesc.opname, op_args,
- rgenop.constTYPE(RESULT))
- return VarRedBox(genvar)
+ opdesc.gv_RESULT)
+ return opdesc.redboxcls(opdesc.gv_RESULT, genvar)
def ll_generate_operation2(opdesc, jitstate, argbox0, argbox1):
ARG0 = opdesc.ARG0
ARG1 = opdesc.ARG1
RESULT = opdesc.RESULT
opname = opdesc.name
- if opdesc.canfold and (isinstance(argbox0, ConstRedBox) and
- isinstance(argbox1, ConstRedBox)):
+ if opdesc.canfold and argbox0.is_constant() and argbox1.is_constant():
# const propagate
- arg0 = argbox0.ll_getvalue(ARG0)
- arg1 = argbox1.ll_getvalue(ARG1)
+ arg0 = rvalue.ll_getvalue(argbox0, ARG0)
+ arg1 = rvalue.ll_getvalue(argbox1, ARG1)
res = opdesc.llop(RESULT, arg0, arg1)
- return ConstRedBox.ll_fromvalue(res)
+ return rvalue.ll_fromvalue(res)
op_args = lltype.malloc(VARLIST.TO, 2)
op_args[0] = argbox0.getgenvar(jitstate)
op_args[1] = argbox1.getgenvar(jitstate)
genvar = rgenop.genop(jitstate.curblock, opdesc.opname, op_args,
- rgenop.constTYPE(RESULT))
- return VarRedBox(genvar)
+ opdesc.gv_RESULT)
+ return opdesc.redboxcls(opdesc.gv_RESULT, genvar)
class StructTypeDesc(object):
_type_cache = weakref.WeakKeyDictionary()
@@ -531,7 +533,7 @@
defaultbox = None
else:
defaultvalue = desc.RESTYPE._defl()
- defaultbox = ConstRedBox.ll_fromvalue(defaultvalue)
+ defaultbox = rvalue.ll_fromvalue(defaultvalue)
defls.append(defaultbox)
self.default_boxes = defls
@@ -613,6 +615,7 @@
RESTYPE = lltype.Ptr(RESTYPE)
self.RESTYPE = RESTYPE
self.gv_resulttype = rgenop.constTYPE(RESTYPE)
+ self.redboxcls = rvalue.ll_redboxcls(RESTYPE)
self.immutable = PTRTYPE.TO._hints.get('immutable', False)
def _freeze_(self):
@@ -660,9 +663,10 @@
pass
def ll_generate_getfield(jitstate, fielddesc, argbox):
- if fielddesc.immutable and isinstance(argbox, ConstRedBox):
- res = getattr(argbox.ll_getvalue(fielddesc.PTRTYPE), fielddesc.fieldname)
- return ConstRedBox.ll_fromvalue(res)
+ if fielddesc.immutable and argbox.is_constant():
+ res = getattr(rvalue.ll_getvalue(argbox, fielddesc.PTRTYPE),
+ fielddesc.fieldname)
+ return rvalue.ll_fromvalue(res)
return argbox.op_getfield(jitstate, fielddesc)
gv_Void = rgenop.constTYPE(lltype.Void)
@@ -672,23 +676,24 @@
def ll_generate_getsubstruct(jitstate, fielddesc, argbox):
- if isinstance(argbox, ConstRedBox):
- res = getattr(argbox.ll_getvalue(fielddesc.PTRTYPE), fielddesc.fieldname)
- return ConstRedBox.ll_fromvalue(res)
+ if argbox.is_constant():
+ res = getattr(rvalue.ll_getvalue(argbox, fielddesc.PTRTYPE),
+ fielddesc.fieldname)
+ return rvalue.ll_fromvalue(res)
return argbox.op_getsubstruct(jitstate, fielddesc)
def ll_generate_getarrayitem(jitstate, fielddesc, argbox, indexbox):
- if (fielddesc.immutable and
- isinstance(argbox, ConstRedBox) and isinstance(indexbox, ConstRedBox)):
- res = argbox.ll_getvalue(fielddesc.PTRTYPE)[indexbox.ll_getvalue(lltype.Signed)]
- return ConstRedBox.ll_fromvalue(res)
+ if fielddesc.immutable and argbox.is_constant() and indexbox.is_constant():
+ array = rvalue.ll_getvalue(argbox, fielddesc.PTRTYPE)
+ res = array[rvalue.ll_getvalue(indexbox, lltype.Signed)]
+ return rvalue.ll_fromvalue(res)
op_args = lltype.malloc(VARLIST.TO, 2)
op_args[0] = argbox.getgenvar(jitstate)
op_args[1] = indexbox.getgenvar(jitstate)
genvar = rgenop.genop(jitstate.curblock, 'getarrayitem', op_args,
fielddesc.gv_resulttype)
- return VarRedBox(genvar)
+ return fielddesc.redboxcls(fielddesc.gv_resulttype, genvar)
##def ll_generate_malloc(jitstate, gv_type, gv_resulttype):
## op_args = lltype.malloc(VARLIST.TO, 1)
@@ -701,33 +706,46 @@
# other jitstate/graph level operations
-def retrieve_jitstate_for_merge(states_dic, jitstate, key, redboxes, types_gv):
+def retrieve_jitstate_for_merge(states_dic, jitstate, key, redboxes):
if key not in states_dic:
- jitstate = enter_block(jitstate, redboxes, types_gv)
- states_dic[key] = redboxes, jitstate.curblock
+ memo = {}
+ frozens = [redbox.freeze(memo) for redbox in redboxes]
+ memo = {}
+ outgoingvarboxes = []
+ for i in range(len(redboxes)):
+ res = frozens[i].exactmatch(redboxes[i], outgoingvarboxes, memo)
+ assert res, "exactmatch() failed"
+ newblock = rgenop.newblock()
+ linkargs = []
+ for box in outgoingvarboxes:
+ linkargs.append(box.getgenvar(None))
+ box.genvar = rgenop.geninputarg(newblock, box.gv_type)
+ rgenop.closelink(jitstate.curoutgoinglink, linkargs, newblock)
+ jitstate.curblock = newblock
+ jitstate.curoutgoinglink = lltype.nullptr(rgenop.LINK.TO)
+ states_dic[key] = frozens, newblock
return jitstate
- oldboxes, oldblock = states_dic[key]
+ frozens, oldblock = states_dic[key]
memo = {}
- incoming = []
+ outgoingvarboxes = []
+ exactmatch = True
for i in range(len(redboxes)):
- oldbox = oldboxes[i]
- newbox = redboxes[i]
- if not oldbox.match(jitstate, newbox, incoming, memo):
- break # mismatch
-## if isinstance(oldbox, VarRedBox): # Always a match
-## incoming.append(newbox.getgenvar(jitstate))
-## continue
-## if oldbox.same_constant(newbox):
-## continue
-## # Mismatch. Generalize to a var
-## break
- else:
- rgenop.closelink(jitstate.curoutgoinglink, incoming, oldblock)
+ frozen = frozens[i]
+ if not frozen.exactmatch(redboxes[i], outgoingvarboxes, memo):
+ exactmatch = False
+
+ if exactmatch:
+ jitstate = enter_block(jitstate, outgoingvarboxes)
+ linkargs = []
+ for box in outgoingvarboxes:
+ linkargs.append(box.getgenvar(jitstate))
+ link = rgenop.closeblock1(jitstate.curblock)
+ rgenop.closelink(link, linkargs, oldblock)
return None
# Make a more general block
- jitstate = enter_block(jitstate, redboxes, types_gv)
+ jitstate = enter_block(jitstate, redboxes)
newblock = rgenop.newblock()
incoming = []
memo = {}
@@ -748,17 +766,14 @@
return jitstate
retrieve_jitstate_for_merge._annspecialcase_ = "specialize:arglltype(2)"
-def enter_block(jitstate, redboxes, types_gv):
+def enter_block(jitstate, redboxes):
newblock = rgenop.newblock()
- jitstate.curblock = newblock
incoming = []
- memo1 = {}
- memo2 = {}
+ memo = {}
for i in range(len(redboxes)):
- redbox = redboxes[i]
- redbox.getallvariables(jitstate, incoming, memo1)
- redboxes[i] = redbox.copybox(newblock, types_gv[i], memo2)
+ redboxes[i].enter_block(newblock, incoming, memo)
rgenop.closelink(jitstate.curoutgoinglink, incoming, newblock)
+ jitstate.curblock = newblock
jitstate.curoutgoinglink = lltype.nullptr(rgenop.LINK.TO)
return jitstate
@@ -814,13 +829,11 @@
finalvar = rgenop.geninputarg(finalblock, gv_return_type)
for link, redbox in return_queue:
newblock = rgenop.newblock()
- jitstate.curblock = newblock
incoming = []
- memo1 = {}
- memo2 = {}
- redbox.getallvariables(jitstate, incoming, memo1)
- newbox = redbox.copybox(newblock, gv_return_type, memo2)
- gv_retval = newbox.getgenvar(jitstate)
+ memo = {}
+ redbox.enter_block(newblock, incoming, memo)
+ jitstate.curblock = newblock
+ gv_retval = redbox.getgenvar(jitstate)
rgenop.closelink(link, incoming, newblock)
newlink = rgenop.closeblock1(newblock)
rgenop.closelink(newlink, [gv_retval], finalblock)
@@ -866,19 +879,18 @@
jitstate.setup()
return jitstate
-def ll_int_box(gv):
- return IntRedBox(gv)
+def ll_int_box(gv_type, gv):
+ return rvalue.IntRedBox(gv_type, gv)
-def ll_double_box(gv):
- return DoubleRedBox(gv)
+def ll_double_box(gv_type, gv):
+ return rvalue.DoubleRedBox(gv_type, gv)
-def ll_addr_box(gv):
- return AddrRedBox(gv)
+def ll_addr_box(gv_type, gv):
+ return rvalue.PtrRedBox(gv_type, gv)
+
+def ll_geninputarg(jitstate, gv_TYPE):
+ return rgenop.geninputarg(jitstate.curblock, gv_TYPE)
-def ll_var_box(jitstate, gv_TYPE):
- genvar = rgenop.geninputarg(jitstate.curblock, gv_TYPE)
- return VarRedBox(genvar)
-
def ll_end_setup_jitstate(jitstate):
jitstate.end_setup()
return jitstate.curblock
Modified: pypy/branch/jit-timeshifter-refactoring/timeshifter/rtyper.py
==============================================================================
--- pypy/branch/jit-timeshifter-refactoring/timeshifter/rtyper.py (original)
+++ pypy/branch/jit-timeshifter-refactoring/timeshifter/rtyper.py Sat Apr 1 23:18:35 2006
@@ -10,7 +10,7 @@
from pypy.rpython import rgenop
from pypy.jit.hintannotator import model as hintmodel
from pypy.jit.hintannotator import container as hintcontainer
-from pypy.jit.timeshifter import rtimeshift
+from pypy.jit.timeshifter import rtimeshift, rvalue
class HintTypeSystem(TypeSystem):
name = "hinttypesystem"
@@ -322,7 +322,7 @@
annmodel.SomePtr(rgenop.CONSTORVAR))
def convert_const(self, ll_value):
- redbox = rtimeshift.ConstRedBox.ll_fromvalue(ll_value)
+ redbox = rvalue.ll_fromvalue(ll_value)
timeshifter = self.timeshifter
return timeshifter.annhelper.delayedconst(timeshifter.r_RedBox, redbox)
Modified: pypy/branch/jit-timeshifter-refactoring/timeshifter/rvalue.py
==============================================================================
--- pypy/branch/jit-timeshifter-refactoring/timeshifter/rvalue.py (original)
+++ pypy/branch/jit-timeshifter-refactoring/timeshifter/rvalue.py Sat Apr 1 23:18:35 2006
@@ -2,9 +2,11 @@
from pypy.rpython.lltypesystem import lltype
-class AbstractRedBox(object):
+class RedBox(object):
- def __init__(self, genvar=rgenop.nullvar):
+ def __init__(self, gv_type, genvar=rgenop.nullvar):
+ assert rgenop.isconst(gv_type) # temporary?
+ self.gv_type = gv_type
self.genvar = genvar # nullvar or a genvar
def __repr__(self):
@@ -19,31 +21,38 @@
def getgenvar(self, jitstate):
return self.genvar
- def ll_fromvalue(value):
- "Make a constant RedBox from a low-level value."
- T = lltype.typeOf(value)
- gv = rgenop.genconst(value)
- if isinstance(T, lltype.Ptr):
- return PtrRedBox(gv)
- elif T is lltype.Float:
- return DoubleRedBox(gv)
- else:
- assert isinstance(T, lltype.Primitive)
- assert T is not lltype.Void, "cannot make red boxes of voids"
- # XXX what about long longs?
- return IntRedBox(gv)
- ll_fromvalue = staticmethod(ll_fromvalue)
-
- def ll_getvalue(self, T):
- "Return the content of a known-to-be-constant RedBox."
- # note: this is specialized by low-level type T, as a low-level helper
- return rgenop.revealconst(T, self.genvar)
+ def enter_block(self, newblock, incoming, memo):
+ if not self.is_constant() and self not in memo:
+ incoming.append(self.genvar)
+ memo[self] = None
+ self.genvar = rgenop.geninputarg(newblock, self.gv_type)
+
+
+def ll_redboxcls(TYPE):
+ if isinstance(TYPE, lltype.Ptr):
+ return PtrRedBox
+ elif TYPE is lltype.Float:
+ return DoubleRedBox
+ else:
+ assert isinstance(TYPE, lltype.Primitive)
+ assert TYPE is not lltype.Void, "cannot make red boxes of voids"
+ # XXX what about long longs?
+ return IntRedBox
+
+def ll_fromvalue(value):
+ "Make a constant RedBox from a low-level value."
+ T = lltype.typeOf(value)
+ gv_type = rgenop.constTYPE(T)
+ gv = rgenop.genconst(value)
+ cls = ll_redboxcls(T)
+ return cls(gv_type, gv)
def ll_getvalue(box, T):
- return box.ll_getvalue(T)
+ "Return the content of a known-to-be-constant RedBox."
+ return rgenop.revealconst(T, box.genvar)
-class IntRedBox(AbstractRedBox):
+class IntRedBox(RedBox):
"A red box that contains a constant integer-like value."
def freeze(self, memo):
@@ -58,7 +67,7 @@
return result
-class DoubleRedBox(AbstractRedBox):
+class DoubleRedBox(RedBox):
"A red box that contains a constant double-precision floating point value."
def freeze(self, memo):
@@ -73,39 +82,46 @@
return result
-class PtrRedBox(AbstractRedBox):
+class PtrRedBox(RedBox):
- def __init__(self, genvar=rgenop.nullvar, content=None):
- AbstractRedBox.__init__(self, genvar)
+ def __init__(self, gv_type, genvar=rgenop.nullvar, content=None):
+ RedBox.__init__(self, gv_type, genvar)
self.content = content # None or an AbstractContainer
def __repr__(self):
if not self.genvar and self.content is not None:
return '<virtual %s>' % (self.content,)
else:
- return AbstractRedBox.__repr__(self)
+ return RedBox.__repr__(self)
def freeze(self, memo):
try:
return memo[self]
except KeyError:
- if self.genvar:
+ if self.content:
+ result = FrozenPtrVirtual()
+ memo[self] = result
+ result.fz_content = self.content.freeze(memo)
+ else:
if self.is_constant():
result = FrozenPtrConst(self.genvar)
else:
result = FrozenPtrVar()
memo[self] = result
- else:
- result = FrozenPtrVirtual()
- memo[self] = result
- result.fz_content = self.content.freeze(memo)
return result
def getgenvar(self, jitstate):
if not self.genvar:
+ assert self.content
self.genvar = self.content.build_runtime_container(jitstate)
return self.genvar
+ def enter_block(self, newblock, incoming, memo):
+ if self.content:
+ self.content.enter_block(newblock, incoming, memo)
+ else:
+ RedBox.enter_block(self, newblock, incoming, memo)
+
# ____________________________________________________________
class FrozenValue(object):
@@ -122,16 +138,16 @@
try:
return memo[self]
except KeyError:
- box = memo[self] = IntRedBox(self.gv_const)
+ box = memo[self] = IntRedBox(gv_type, self.gv_const)
return box
- def exactmatch(self, box, outgoingvars, memo):
+ def exactmatch(self, box, outgoingvarboxes, memo):
if (box.is_constant() and
rgenop.revealconst(lltype.Signed, self.gv_const) ==
rgenop.revealconst(lltype.Signed, box.genvar)):
return True
else:
- outgoingvars.append(box)
+ outgoingvarboxes.append(box)
return False
@@ -142,18 +158,18 @@
return memo[self]
except KeyError:
gv_value = rgenop.geninputarg(block, gv_type)
- box = memo[self] = IntRedBox(gv_value)
+ box = memo[self] = IntRedBox(gv_type, gv_value)
return box
- def exactmatch(self, box, outgoingvars, memo):
+ def exactmatch(self, box, outgoingvarboxes, memo):
if self not in memo:
memo[self] = box
- outgoingvars.append(box)
+ outgoingvarboxes.append(box)
return True
elif memo[self] is box:
return True
else:
- outgoingvars.append(box)
+ outgoingvarboxes.append(box)
return False
@@ -166,16 +182,16 @@
try:
return memo[self]
except KeyError:
- box = memo[self] = DoubleRedBox(self.gv_const)
+ box = memo[self] = DoubleRedBox(gv_type, self.gv_const)
return box
- def exactmatch(self, box, outgoingvars, memo):
+ def exactmatch(self, box, outgoingvarboxes, memo):
if (box.is_constant() and
rgenop.revealconst(lltype.Double, self.gv_const) ==
rgenop.revealconst(lltype.Double, box.genvar)):
return True
else:
- outgoingvars.append(box)
+ outgoingvarboxes.append(box)
return False
@@ -186,18 +202,18 @@
return memo[self]
except KeyError:
gv_value = rgenop.geninputarg(block, gv_type)
- box = memo[self] = DoubleRedBox(gv_value)
+ box = memo[self] = DoubleRedBox(gv_type, gv_value)
return box
- def exactmatch(self, box, outgoingvars, memo):
+ def exactmatch(self, box, outgoingvarboxes, memo):
if self not in memo:
memo[self] = box
- outgoingvars.append(box)
+ outgoingvarboxes.append(box)
return True
elif memo[self] is box:
return True
else:
- outgoingvars.append(box)
+ outgoingvarboxes.append(box)
return False
@@ -210,16 +226,16 @@
try:
return memo[self]
except KeyError:
- box = memo[self] = PtrRedBox(self.gv_const)
+ box = memo[self] = PtrRedBox(gv_type, self.gv_const)
return box
- def exactmatch(self, box, outgoingvars, memo):
+ def exactmatch(self, box, outgoingvarboxes, memo):
if (box.is_constant() and
rgenop.revealconst(lltype.Address, self.gv_const) ==
rgenop.revealconst(lltype.Address, box.genvar)):
return True
else:
- outgoingvars.append(box)
+ outgoingvarboxes.append(box)
return False
@@ -230,18 +246,18 @@
return memo[self]
except KeyError:
gv_value = rgenop.geninputarg(block, gv_type)
- box = memo[self] = PtrRedBox(gv_value)
+ box = memo[self] = PtrRedBox(gv_type, gv_value)
return box
- def exactmatch(self, box, outgoingvars, memo):
+ def exactmatch(self, box, outgoingvarboxes, memo):
if self not in memo:
memo[self] = box
- outgoingvars.append(box)
+ outgoingvarboxes.append(box)
return True
elif memo[self] is box:
return True
else:
- outgoingvars.append(box)
+ outgoingvarboxes.append(box)
return False
@@ -251,14 +267,15 @@
try:
return memo[self]
except KeyError:
- box = memo[self] = PtrRedBox()
+ box = memo[self] = PtrRedBox(gv_type)
box.content = self.fz_content.unfreeze(memo, block)
return box
- def exactmatch(self, box, outgoingvars, memo):
+ def exactmatch(self, box, outgoingvarboxes, memo):
assert isinstance(box, PtrRedBox)
if box.content is None:
- outgoingvars.append(box)
+ outgoingvarboxes.append(box)
return False
else:
- return self.fz_content.exactmatch(box.content, outgoingvars, memo)
+ return self.fz_content.exactmatch(box.content, outgoingvarboxes,
+ memo)
Modified: pypy/branch/jit-timeshifter-refactoring/timeshifter/test/test_timeshift.py
==============================================================================
--- pypy/branch/jit-timeshifter-refactoring/timeshifter/test/test_timeshift.py (original)
+++ pypy/branch/jit-timeshifter-refactoring/timeshifter/test/test_timeshift.py Sat Apr 1 23:18:35 2006
@@ -93,16 +93,18 @@
# red
assert residual_v == [llvalue], "XXX for now"
TYPE = htshift.originalconcretetype(v)
- box = llinterp.eval_graph(htshift.ll_var_box_graph, [jitstate,
- rgenop.constTYPE(TYPE)])
+ gv_type = rgenop.constTYPE(TYPE)
+ gvar = llinterp.eval_graph(htshift.ll_geninputarg_graph, [jitstate,
+ gv_type])
if i in opt_consts: # XXX what should happen here interface wise is unclear
- if isinstance(lltype.typeOf(llvalue), lltype.Ptr):
- ll_box_graph = htshift.ll_addr_box_graph
- elif isinstance(llvalue, float):
- ll_box_graph = htshift.ll_double_box_graph
- else:
- ll_box_graph = htshift.ll_int_box_graph
- box = llinterp.eval_graph(ll_box_graph, [rgenop.genconst(llvalue)])
+ gvar = rgenop.genconst(llvalue)
+ if isinstance(lltype.typeOf(llvalue), lltype.Ptr):
+ ll_box_graph = htshift.ll_addr_box_graph
+ elif isinstance(llvalue, float):
+ ll_box_graph = htshift.ll_double_box_graph
+ else:
+ ll_box_graph = htshift.ll_int_box_graph
+ box = llinterp.eval_graph(ll_box_graph, [gv_type, gvar])
graph1args.append(box)
residual_graph_args.append(llvalue)
startblock = llinterp.eval_graph(htshift.ll_end_setup_jitstate_graph, [jitstate])
Modified: pypy/branch/jit-timeshifter-refactoring/timeshifter/timeshift.py
==============================================================================
--- pypy/branch/jit-timeshifter-refactoring/timeshifter/timeshift.py (original)
+++ pypy/branch/jit-timeshifter-refactoring/timeshifter/timeshift.py Sat Apr 1 23:18:35 2006
@@ -3,8 +3,8 @@
from pypy.objspace.flow import model as flowmodel
from pypy.annotation import model as annmodel
from pypy.annotation import listdef, dictdef
+from pypy.jit.timeshifter import rvalue
from pypy.jit.timeshifter.rtimeshift import VARLIST, JITState
-from pypy.jit.timeshifter.rtimeshift import make_types_const
from pypy.rpython import rmodel, rlist, rdict, rgenop, annlowlevel
from pypy.rpython.lltypesystem import rtuple
from pypy.jit.timeshifter import rtimeshift
@@ -25,7 +25,7 @@
self.annhelper = annlowlevel.MixLevelHelperAnnotator(rtyper)
self.s_JITState, self.r_JITState = self.s_r_instanceof(JITState)
- self.s_RedBox, self.r_RedBox = self.s_r_instanceof(RedBox)
+ self.s_RedBox, self.r_RedBox = self.s_r_instanceof(rvalue.RedBox)
getrepr = self.rtyper.getrepr
@@ -47,20 +47,20 @@
[], self.s_JITState)
self.ll_int_box_graph = self.annhelper.getgraph(
rtimeshift.ll_int_box,
- [rgenop.s_ConstOrVar],
+ [rgenop.s_ConstOrVar, rgenop.s_ConstOrVar],
self.s_RedBox)
self.ll_addr_box_graph = self.annhelper.getgraph(
rtimeshift.ll_addr_box,
- [rgenop.s_ConstOrVar],
+ [rgenop.s_ConstOrVar, rgenop.s_ConstOrVar],
self.s_RedBox)
self.ll_double_box_graph = self.annhelper.getgraph(
rtimeshift.ll_int_box,
- [rgenop.s_ConstOrVar],
+ [rgenop.s_ConstOrVar, rgenop.s_ConstOrVar],
self.s_RedBox)
- self.ll_var_box_graph = self.annhelper.getgraph(
- rtimeshift.ll_var_box,
+ self.ll_geninputarg_graph = self.annhelper.getgraph(
+ rtimeshift.ll_geninputarg,
[self.s_JITState, annmodel.SomePtr(rgenop.CONSTORVAR)],
- self.s_RedBox)
+ rgenop.s_ConstOrVar)
self.ll_end_setup_jitstate_graph = self.annhelper.getgraph(
rtimeshift.ll_end_setup_jitstate,
[self.s_JITState],
@@ -216,7 +216,7 @@
def make_const_box(self, llops, r_green, v_value):
v_box = llops.genmixlevelhelpercall(
- rtimeshift.ConstRedBox.ll_fromvalue,
+ rvalue.ll_fromvalue,
[r_green.annotation()], [v_value], self.s_RedBox)
return v_box
@@ -265,7 +265,6 @@
getrepr = self.rtyper.getrepr
v_boxes = self.build_box_list(llops, boxes_v)
- TYPES_gv = make_types_const(TYPES)
if nentrylinks > 1:
enter_block_logic = self.bookkeeping_enter_for_join
@@ -277,8 +276,7 @@
enter_block_logic(args_r, newinputargs,
before_block,
llops,
- v_boxes,
- TYPES_gv)
+ v_boxes)
def build_box_list(self, llops, boxes_v):
type_erased_v = [llops.convertvar(v_box, self.r_RedBox,
@@ -287,13 +285,11 @@
v_boxes = rlist.newlist(llops, self.r_box_list, type_erased_v)
return v_boxes
- def bookkeeping_enter_simple(self, args_r, newinputargs, before_block, llops, v_boxes,
- TYPES_gv):
- c_TYPES = rmodel.inputconst(VARLIST, TYPES_gv)
+ def bookkeeping_enter_simple(self, args_r, newinputargs, before_block,
+ llops, v_boxes):
v_newjitstate = llops.genmixlevelhelpercall(rtimeshift.enter_block,
- [self.s_JITState, self.s_box_list,
- annmodel.SomePtr(VARLIST)],
- [newinputargs[0], v_boxes, c_TYPES],
+ [self.s_JITState, self.s_box_list],
+ [newinputargs[0], v_boxes],
self.s_JITState)
bridge = before_block.exits[0]
@@ -310,8 +306,8 @@
# ll_retrieve_jitstate_for_merge is supposed to use the "constant" dict as cache
# mapping green values combinations to frozen states for red boxes values
# and generated blocks
- def bookkeeping_enter_for_join(self, args_r, newinputargs, before_block, llops, v_boxes,
- TYPES_gv):
+ def bookkeeping_enter_for_join(self, args_r, newinputargs, before_block,
+ llops, v_boxes):
getrepr = self.rtyper.getrepr
items_s = []
key_v = []
@@ -338,7 +334,7 @@
def merge_point(jitstate, key, boxes):
return rtimeshift.retrieve_jitstate_for_merge(cache, jitstate,
- key, boxes, TYPES_gv)
+ key, boxes)
v_newjitstate = llops.genmixlevelhelpercall(merge_point,
[self.s_JITState, s_key_tuple, self.s_box_list],
More information about the Pypy-commit
mailing list