[pypy-svn] r23044 - in pypy/dist/pypy: jit rpython rpython/test
pedronis at codespeak.net
pedronis at codespeak.net
Sun Feb 5 18:15:45 CET 2006
Author: pedronis
Date: Sun Feb 5 18:15:38 2006
New Revision: 23044
Modified:
pypy/dist/pypy/jit/llabstractinterp.py
pypy/dist/pypy/jit/llvalue.py
pypy/dist/pypy/rpython/extfunctable.py
pypy/dist/pypy/rpython/rgenop.py
pypy/dist/pypy/rpython/test/test_rgenop.py
Log:
(arigo, pedronis)
some first steps toward rtyping of rgenop operations.
We need to rethink the unadorned void Constant in genop arg list
approach.
Modified: pypy/dist/pypy/jit/llabstractinterp.py
==============================================================================
--- pypy/dist/pypy/jit/llabstractinterp.py (original)
+++ pypy/dist/pypy/jit/llabstractinterp.py Sun Feb 5 18:15:38 2006
@@ -258,20 +258,24 @@
self.args_genv = [v.getgenvar(builder) for v in args_v]
self.frozenstate = frozenstate
self.link = None
+ self.target_set = False
def setreturn(self):
rgenop.closereturnlink(self.link, self.args_genv[0])
+ self.target_set = True
def settarget(self, block, blockargs):
args = []
for v1, v2 in zip(self.args_genv, blockargs):
assert isinstance(v2, (AVariable, AConstant))
if isinstance(v2, AConstant):
- assert v1.value == v2.value # sanity check violating encapsulation
+ # sanity check violating encapsulation
+ v1 = rgenop.reveal(v1)
+ assert v1.value == v2.value
else:
args.append(v1)
rgenop.closelink(self.link, args, block)
-
+ self.target_set = True
class GraphState(object):
"""Entry state of a graph."""
@@ -286,10 +290,12 @@
self.frozenstate = frozenstate
#self.a_return = None
self.state = "before"
+ self.target_set = False
def settarget(self, block, blockargs):
self.startblock = block
-
+ self.target_set = True
+
def complete(self):
assert self.state != "during"
if self.state == "after":
@@ -390,8 +396,7 @@
seen[ls] = True
pending.append(ls)
else:
- # XXX don't use ls.link.target!
- if ls.link is None or ls.link.target is None:
+ if ls.link is None or not ls.target_set:
# resolve the LinkState to go to the return
# or except block
if len(ls.args_v) == 1:
@@ -522,7 +527,9 @@
assert len(newlinkstates) == 2
- false_link, true_link = rgenop.closeblock2(b, newexitswitch.getgenvar(self))
+ exitspair = rgenop.closeblock2(b, newexitswitch.getgenvar(self))
+ false_link, true_link = exitspair.item0, exitspair.item1
+
cases = {False: false_link, True: true_link}
for ls in newlinkstates:
ls.link = cases[ls.exitcase]
Modified: pypy/dist/pypy/jit/llvalue.py
==============================================================================
--- pypy/dist/pypy/jit/llvalue.py (original)
+++ pypy/dist/pypy/jit/llvalue.py Sun Feb 5 18:15:38 2006
@@ -92,7 +92,9 @@
if self.content is None:
raise ValueError("ll_dummy_value.forcevarorconst()")
genvar = self.content.build_runtime_container(builder)
- assert self.content.T == genvar.concretetype.TO # sanity check
+ # sanity check violating encapsulation
+ var = rgenop.reveal(genvar)
+ assert self.content.T == var.concretetype.TO
self.runtimevar = AVariable(lltype.Ptr(self.content.T), genvar=genvar)
self.content = None
return self.runtimevar
Modified: pypy/dist/pypy/rpython/extfunctable.py
==============================================================================
--- pypy/dist/pypy/rpython/extfunctable.py (original)
+++ pypy/dist/pypy/rpython/extfunctable.py Sun Feb 5 18:15:38 2006
@@ -59,6 +59,8 @@
self._TYPE = OPAQUE
return self._TYPE
+ def set_lltype(self, TYPE):
+ self._TYPE = TYPE
class ImportMe:
"Lazily imported module, for circular imports :-/"
Modified: pypy/dist/pypy/rpython/rgenop.py
==============================================================================
--- pypy/dist/pypy/rpython/rgenop.py (original)
+++ pypy/dist/pypy/rpython/rgenop.py Sun Feb 5 18:15:38 2006
@@ -7,43 +7,71 @@
from pypy.rpython.lltypesystem import lltype
from pypy.objspace.flow import model as flowmodel
from pypy.translator.simplify import eliminate_empty_blocks, join_blocks
+from pypy.rpython.module.support import init_opaque_object
+from pypy.rpython.module.support import to_opaque_object, from_opaque_object
+# for debugging, sanity checks in non-RPython code
+reveal = from_opaque_object
+
+def initblock(opaqueptr):
+ init_opaque_object(opaqueptr, flowmodel.Block([]))
def newblock():
- return flowmodel.Block([])
+ blockcontainer = lltype.malloc(BLOCKCONTAINERTYPE)
+ initblock(blockcontainer.obj)
+ return blockcontainer
-def geninputarg(block, CONCRETE_TYPE):
+def geninputarg(blockcontainer, CONCRETE_TYPE):
+ block = from_opaque_object(blockcontainer.obj)
v = flowmodel.Variable()
v.concretetype = CONCRETE_TYPE
block.inputargs.append(v)
- return v
+ return to_opaque_object(v)
-def genop(block, opname, vars, RESULT_TYPE):
+def _inputvars(vars):
+ if not isinstance(vars, list):
+ vars = vars.ll_items()
+ res = []
for v in vars:
+ if isinstance(v, flowmodel.Constant):
+ # XXX for now: pass through Void constants
+ assert v.concretetype == lltype.Void
+ else:
+ v = from_opaque_object(v)
assert isinstance(v, (flowmodel.Constant, flowmodel.Variable))
-
+ res.append(v)
+ return res
+
+def genop(blockcontainer, opname, vars, RESULT_TYPE):
+ block = from_opaque_object(blockcontainer.obj)
+ opvars = _inputvars(vars)
v = flowmodel.Variable()
v.concretetype = RESULT_TYPE
- op = flowmodel.SpaceOperation(opname, vars, v)
+ op = flowmodel.SpaceOperation(opname, opvars, v)
block.operations.append(op)
- return v
+ return to_opaque_object(v)
-def gencallableconst(block, name, target, FUNCTYPE):
+def gencallableconst(blockcontainer, name, targetcontainer, FUNCTYPE):
+ # is name useful, is it runtime variable?
+ target = from_opaque_object(targetcontainer.obj)
fptr = lltype.functionptr(FUNCTYPE, name,
- graph=buildgraph(target))
- return genconst(block, fptr)
+ graph=_buildgraph(target))
+ return genconst(blockcontainer, fptr)
-def genconst(block, llvalue):
+def genconst(blockcontainer, llvalue):
v = flowmodel.Constant(llvalue)
v.concretetype = lltype.typeOf(llvalue)
- return v
+ return to_opaque_object(v)
-def closeblock1(block):
+def closeblock1(blockcontainer):
+ block = from_opaque_object(blockcontainer.obj)
link = flowmodel.Link([], None)
block.closeblock(link)
- return link
+ return to_opaque_object(link)
-def closeblock2(block, exitswitch):
+def closeblock2into(blockcontainer, exitswitch, linkpair):
+ block = from_opaque_object(blockcontainer.obj)
+ exitswitch = from_opaque_object(exitswitch)
assert isinstance(exitswitch, flowmodel.Variable)
block.exitswitch = exitswitch
false_link = flowmodel.Link([], None)
@@ -53,9 +81,15 @@
true_link.exitcase = True
true_link.llexitcase = True
block.closeblock(false_link, true_link)
- return false_link, true_link
+ linkpair.item0 = to_opaque_object(false_link)
+ linkpair.item1 = to_opaque_object(true_link)
+
+def closeblock2(blockcontainer, exitswitch):
+ linkpair = lltype.malloc(LINKPAIR)
+ closeblock2into(blockcontainer, exitswitch, linkpair)
+ return linkpair
-def closelink(link, vars, targetblock):
+def _closelink(link, vars, targetblock):
if isinstance(link, flowmodel.Link):
for v in vars:
assert isinstance(v, (flowmodel.Variable, flowmodel.Constant))
@@ -70,12 +104,20 @@
else:
raise TypeError
+def closelink(link, vars, targetblockcontainer):
+ link = from_opaque_object(link)
+ targetblock = from_opaque_object(targetblockcontainer.obj)
+ vars = _inputvars(vars)
+ return _closelink(link, vars, targetblock)
+
def closereturnlink(link, returnvar):
+ returnvar = from_opaque_object(returnvar)
+ link = from_opaque_object(link)
v = flowmodel.Variable()
v.concretetype = returnvar.concretetype
pseudoreturnblock = flowmodel.Block([v])
pseudoreturnblock.operations = ()
- closelink(link, [returnvar], pseudoreturnblock)
+ _closelink(link, [returnvar], pseudoreturnblock)
def _patchgraph(graph):
returntype = None
@@ -96,7 +138,7 @@
from pypy.rpython.typesystem import LowLevelTypeSystem
self.type_system = LowLevelTypeSystem.instance
-def buildgraph(block):
+def _buildgraph(block):
graph = flowmodel.FunctionGraph('?', block)
_patchgraph(graph)
flowmodel.checkgraph(graph)
@@ -105,8 +147,33 @@
graph.rgenop = True
return graph
-def runblock(block, args):
+def buildgraph(blockcontainer):
+ block = from_opaque_object(blockcontainer.obj)
+ return _buildgraph(block)
+
+def runblock(blockcontainer, args):
+ block = from_opaque_object(blockcontainer.obj)
from pypy.rpython.llinterp import LLInterpreter
- graph = buildgraph(block)
+ graph = _buildgraph(block)
llinterp = LLInterpreter(PseudoRTyper())
return llinterp.eval_graph(graph, args)
+
+# ____________________________________________________________
+# RTyping of the above functions
+
+from pypy.rpython.extfunctable import declaretype, declareptrtype, declare
+
+blocktypeinfo = declaretype(flowmodel.Block, "Block")
+vartypeinfo = declareptrtype(flowmodel.Variable, "VarOrConst")
+consttypeinfo = declareptrtype(flowmodel.Constant, "VarOrConst")
+consttypeinfo.set_lltype(vartypeinfo.get_lltype()) # force same lltype
+linktypeinfo = declareptrtype(flowmodel.Link, "Link")
+
+BLOCKCONTAINERTYPE = blocktypeinfo.get_lltype()
+LINKTYPE = linktypeinfo.get_lltype()
+
+fieldnames = ['item%d' % i for i in range(2)]
+lltypes = [lltype.Ptr(LINKTYPE)]*2
+fields = tuple(zip(fieldnames, lltypes))
+LINKPAIR = lltype.GcStruct('tuple2', *fields)
+
Modified: pypy/dist/pypy/rpython/test/test_rgenop.py
==============================================================================
--- pypy/dist/pypy/rpython/test/test_rgenop.py (original)
+++ pypy/dist/pypy/rpython/test/test_rgenop.py Sun Feb 5 18:15:38 2006
@@ -1,15 +1,44 @@
from pypy.rpython.rgenop import *
from pypy.rpython.lltypesystem.lltype import *
+from pypy.rpython.test.test_llinterp import interpret
+from pypy.rpython.module.support import from_opaque_object
+from pypy.objspace.flow import model as flowmodel
-def test_square():
+def build_square():
"""def square(v0): return v0*v0"""
block = newblock()
v0 = geninputarg(block, Signed)
v1 = genop(block, 'int_mul', [v0, v0], Signed)
link = closeblock1(block)
closereturnlink(link, v1)
+ return block
+
+def test_square():
+ block = build_square()
+ res = runblock(block, [17])
+ assert res == 289
+
+def NO_test_rtype_newblock():
+ def emptyblock():
+ return newblock()
+ blockcontainer = interpret(emptyblock, [])
+ block = from_opaque_object(blockcontainer.obj)
+ assert isinstance(block, flowmodel.Block)
+
+def NO_test_rtype_geninputarg():
+ def onearg():
+ block = newblock()
+ v0 = geninputarg(block, Signed)
+ return v0
+ opaquev = interpret(onearg, [])
+ v = from_opaque_object(opaquev)
+ assert isinstance(v, flowmodel.Variable)
+
+def NO_test_rtype_build_square():
+ blockcontainer = interpret(build_square, [])
+ block = from_opaque_object(blockcontainer.obj)
res = runblock(block, [17])
assert res == 289
@@ -25,7 +54,8 @@
v0 = geninputarg(block, Signed)
const0 = genconst(block, 0)
v1 = genop(block, 'int_lt', [v0, const0], Bool)
- false_link, true_link = closeblock2(block, v1)
+ exitspair = closeblock2(block, v1)
+ false_link, true_link = exitspair.item0, exitspair.item1
closereturnlink(true_link, const0)
closereturnlink(false_link, v0)
@@ -57,7 +87,8 @@
result1 = genop(loopblock, 'int_mul', [result0, i0], Signed)
i1 = genop(loopblock, 'int_add', [i0, const1], Signed)
v2 = genop(loopblock, 'int_le', [i1, v1], Bool)
- false_link, true_link = closeblock2(loopblock, v2)
+ exitspair = closeblock2(loopblock, v2)
+ false_link, true_link = exitspair.item0, exitspair.item1
closereturnlink(false_link, result1)
closelink(true_link, [result1, i1, v1], loopblock)
More information about the Pypy-commit
mailing list