[pypy-svn] r22638 - in pypy/dist/pypy: doc/discussion jit rpython
ac at codespeak.net
ac at codespeak.net
Wed Jan 25 13:12:00 CET 2006
Author: ac
Date: Wed Jan 25 13:11:59 2006
New Revision: 22638
Modified:
pypy/dist/pypy/doc/discussion/draft-jit-ideas.txt
pypy/dist/pypy/jit/llabstractinterp.py
pypy/dist/pypy/jit/llcontainer.py
pypy/dist/pypy/jit/llvalue.py
pypy/dist/pypy/jit/vlist.py
pypy/dist/pypy/rpython/rgenop.py
pypy/dist/pypy/rpython/rlist.py
Log:
(pedronis, arre)
First steps in refactoring llabsinterp to use the API in rgenop.
Modified: pypy/dist/pypy/doc/discussion/draft-jit-ideas.txt
==============================================================================
--- pypy/dist/pypy/doc/discussion/draft-jit-ideas.txt (original)
+++ pypy/dist/pypy/doc/discussion/draft-jit-ideas.txt Wed Jan 25 13:11:59 2006
@@ -100,6 +100,8 @@
* genconst(block, llvalue) -> (result var)
+* addconst(block, const) -> (result var)
+
* closeblock1(block) -> link
* closeblock2(block, exitswitch-var) -> (false_link, true_link)
Modified: pypy/dist/pypy/jit/llabstractinterp.py
==============================================================================
--- pypy/dist/pypy/jit/llabstractinterp.py (original)
+++ pypy/dist/pypy/jit/llabstractinterp.py Wed Jan 25 13:11:59 2006
@@ -9,6 +9,7 @@
from pypy.jit.llvalue import FlattenMemo, MatchMemo, FreezeMemo, UnfreezeMemo
from pypy.jit.llcontainer import LLAbstractContainer, virtualcontainervalue
from pypy.jit.llcontainer import hasllcontent
+from pypy.rpython import rgenop
# ____________________________________________________________
@@ -93,15 +94,15 @@
result.frozen = True # for debugging
return result
- def unfreeze(self, memo):
+ def unfreeze(self, memo, block):
assert self.frozen, "unfreeze(): state not frozen"
if self.back is not None:
- new_back = self.back.unfreeze(memo)
+ new_back = self.back.unfreeze(memo, block)
else:
new_back = None
new_args_a = []
for v, a in zip(self.getlivevars(), self.args_a):
- a = a.unfreeze(memo)
+ a = a.unfreeze(memo, block)
# try to preserve the name
if isinstance(a.runtimevar, Variable):
a.runtimevar.rename(v)
@@ -536,18 +537,17 @@
def __init__(self, interp, initialstate, key):
self.interp = interp
+ self.newblock = rgenop.newblock()
memo = UnfreezeMemo(key)
- self.runningstate = initialstate.unfreeze(memo)
+ self.runningstate = initialstate.unfreeze(memo, self.newblock)
assert list(memo.propagateconsts) == [] # all items consumed
self.newinputargs = self.runningstate.getruntimevars()
assert len(self.newinputargs) == len(key)
# {Variables-of-origblock: a_value}
self.bindings = self.runningstate.getbindings()
- self.residual_operations = []
def buildblock(self, newexitswitch, newlinkstates):
- b = Block([v for v in self.newinputargs if isinstance(v, Variable)])
- b.operations = self.residual_operations
+ b = self.newblock
b.exitswitch = newexitswitch
exits = []
for ls in newlinkstates:
@@ -559,6 +559,15 @@
b.closeblock(*exits)
return b
+ def genop(self, opname, args, RESULT_TYPE):
+ return rgenop.genop(self.newblock, opname, args, RESULT_TYPE)
+
+ def genconst(self, llvalue):
+ return rgenop.genconst(self.newblock, llvalue)
+
+ def addconst(self, const):
+ return rgenop.addconst(self.newblock, const)
+
def binding(self, v):
if isinstance(v, Constant):
return LLAbstractValue(v)
@@ -598,16 +607,12 @@
self.record_origin(a_result, args_a)
return a_result
- def residual(self, opname, args_a, a_result):
- v_result = a_result.forcevarorconst(self)
- if isinstance(v_result, Constant):
- v_result = newvar(v_result.concretetype)
- op = SpaceOperation(opname,
- [a.forcevarorconst(self) for a in args_a],
- v_result)
- print 'keep:', op
- self.residual_operations.append(op)
-
+ def residual(self, op, args_a):
+ retvar = rgenop.genop(self.newblock, op.opname,
+ [a.forcevarorconst(self) for a in args_a],
+ op.result.concretetype)
+ return LLAbstractValue(retvar)
+
def residualize(self, op, args_a, constant_op=None):
if constant_op:
RESULT = op.result.concretetype
@@ -616,10 +621,9 @@
a_result = self.constantfold(constant_op, args_a)
if a_result is not None:
return a_result
- a_result = LLAbstractValue(dupvar(op.result))
+ a_result = self.residual(op, args_a)
if constant_op:
self.record_origin(a_result, args_a)
- self.residual(op.opname, args_a, a_result)
return a_result
def record_origin(self, a_result, args_a):
@@ -762,8 +766,6 @@
if not any_concrete:
return None
- a_result = LLAbstractValue(dupvar(op.result))
- a_real_result = a_result
graphstate = self.interp.schedule_graph(args_a, origgraph)
#print 'SCHEDULE_GRAPH', args_a, '==>', graphstate.copygraph.name
if graphstate.state != "during":
@@ -782,12 +784,11 @@
ARGS.append(a.getconcretetype())
new_args_a.append(a)
args_a = new_args_a
- TYPE = lltype.FuncType(ARGS, a_result.getconcretetype())
+ TYPE = lltype.FuncType(ARGS, op.result.concretetype)
fptr = lltype.functionptr(
TYPE, graphstate.copygraph.name, graph=graphstate.copygraph)
a_func = LLAbstractValue(const(fptr))
- self.residual("direct_call", [a_func] + args_a, a_result)
- return a_real_result
+ return self.residual(op, [a_func] + args_a)
def op_getfield(self, op, a_ptr, a_attrname):
if hasllcontent(a_ptr):
@@ -878,9 +879,7 @@
for a in memo.result:
v = a.runtimevar
if isinstance(v, Variable) and not v.concretetype._is_atomic():
- op = SpaceOperation('keepalive', [v], newvar(lltype.Void))
- print 'virtual:', op
- self.residual_operations.append(op)
+ rgenop.genop(self.newblock, 'keepalive', [v], lltype.Void)
return ll_no_return_value
# High-level operation dispatcher
Modified: pypy/dist/pypy/jit/llcontainer.py
==============================================================================
--- pypy/dist/pypy/jit/llcontainer.py (original)
+++ pypy/dist/pypy/jit/llcontainer.py Wed Jan 25 13:11:59 2006
@@ -22,7 +22,7 @@
def freeze(self, memo):
return self
- def unfreeze(self, memo):
+ def unfreeze(self, memo, block):
return self
@@ -50,26 +50,22 @@
self.fields[name] = a_value
def build_runtime_container(self, builder):
- v_result = newvar(lltype.Ptr(self.T))
+ RESULT_TYPE = lltype.Ptr(self.T)
if self.a_parent is not None:
v_parent = self.a_parent.forcevarorconst(builder)
- op = SpaceOperation('getsubstruct', [v_parent,
- const(self.parentindex,
- lltype.Void)],
- v_result)
- print 'force:', op
- builder.residual_operations.append(op)
+ parentindex = builder.addconst(const(self.parentindex,
+ lltype.Void))
+ v_result = builder.genop('getsubstruct',
+ [v_parent,parentindex], RESULT_TYPE)
else:
+ t = builder.addconst(const(self.T, lltype.Void))
if self.T._is_varsize():
- op = SpaceOperation('malloc_varsize', [
- const(self.T, lltype.Void),
- const(self.length, lltype.Signed)],
- v_result)
+
+ v_result = builder.genop('malloc_varsize',
+ [t, builder.genconst(self.length)],
+ RESULT_TYPE)
else:
- op = SpaceOperation('malloc', [const(self.T, lltype.Void)],
- v_result)
- print 'force:', op
- builder.residual_operations.append(op)
+ v_result = builder.genop('malloc', [t], RESULT_TYPE)
self.buildcontent(builder, v_result)
return v_result
@@ -81,19 +77,15 @@
T = self.fieldtype(name)
if isinstance(T, lltype.ContainerType):
# initialize the substructure/subarray
- v_subptr = newvar(lltype.Ptr(T))
- op = SpaceOperation('getsubstruct',
- [v_target, const(name, lltype.Void)],
- v_subptr)
- print 'force:', op
- builder.residual_operations.append(op)
+ c_name = builder.addconst(const(name, lltype.Void))
+ v_subptr = builder.genop('getsubstruct',
+ [v_target, c_name],
+ lltype.Ptr(T))
assert isinstance(a_value.content, LLVirtualContainer)
a_value.content.buildcontent(builder, v_subptr)
else:
v_value = a_value.forcevarorconst(builder)
- op = self.setop(v_target, name, v_value)
- print 'force:', op
- builder.residual_operations.append(op)
+ self.setop(builder, v_target, name, v_value)
def flatten(self, memo):
assert self not in memo.seen; memo.seen[self] = True # debugging only
@@ -138,13 +130,13 @@
result.fields[name] = a_frozen
return result
- def unfreeze(self, memo):
+ def unfreeze(self, memo, block):
result = self.__class__(self.T, self.length)
if self.a_parent is not None:
- result.a_parent = self.a_parent.unfreeze(memo)
+ result.a_parent = self.a_parent.unfreeze(memo, block)
result.parentindex = self.parentindex
for name in self.names:
- a = self.fields[name].unfreeze(memo)
+ a = self.fields[name].unfreeze(memo, block)
result.fields[name] = a
return result
@@ -168,11 +160,10 @@
def fieldtype(self, name):
return getattr(self.T, name)
- def setop(self, v_target, name, v_value):
- return SpaceOperation('setfield', [v_target,
- const(name, lltype.Void),
- v_value],
- newvar(lltype.Void))
+ def setop(self, builder, v_target, name, v_value):
+ c_name = builder.addconst(const(name, lltype.Void))
+ builder.genop('setfield', [v_target, c_name, v_value],
+ lltype.Void)
class LLVirtualArray(LLVirtualContainer):
@@ -196,10 +187,10 @@
return self.T.OF
def setop(self, v_target, name, v_value):
- return SpaceOperation('setarrayitem', [v_target,
- const(name, lltype.Signed),
- v_value],
- newvar(lltype.Void))
+ builder.genop('setarrayitem', [v_target,
+ builder.genconst(name),
+ v_value],
+ lltype.Void)
def virtualcontainervalue(T, length=None):
Modified: pypy/dist/pypy/jit/llvalue.py
==============================================================================
--- pypy/dist/pypy/jit/llvalue.py (original)
+++ pypy/dist/pypy/jit/llvalue.py Wed Jan 25 13:11:59 2006
@@ -1,6 +1,6 @@
from pypy.objspace.flow.model import Variable, Constant
from pypy.rpython.lltypesystem import lltype
-
+from pypy.rpython import rgenop
class LLAbstractValue(object):
"""An abstract value, propagated through the blocks of the low-level
@@ -112,7 +112,7 @@
def flatten(self, memo):
pass
- def unfreeze(self, memo):
+ def unfreeze(self, memo, block):
return ll_dummy_value
def match(self, a_value, memo):
@@ -129,7 +129,7 @@
"""
pass
- def unfreeze(self, memo):
+ def unfreeze(self, memo, block):
"""Create an un-frozen copy of a frozen value recursively,
creating fresh Variables.
"""
@@ -160,7 +160,7 @@
"""
memo.result.append(self)
- def unfreeze(self, memo):
+ def unfreeze(self, memo, block):
"""Create an un-frozen copy of a frozen value recursively,
creating fresh Variables.
"""
@@ -171,7 +171,7 @@
v = propagateconst # allowed to propagate as a Constant
assert v.concretetype == self.concretetype
else:
- v = newvar(self.concretetype)
+ v = rgenop.geninputarg(block, self.concretetype)
result = LLAbstractValue(v)
result.origin.append(self)
return result
@@ -196,7 +196,7 @@
memo.seen[self] = True
self.fz_content.flatten(memo)
- def unfreeze(self, memo):
+ def unfreeze(self, memo, block):
"""Create an un-frozen copy of a frozen value recursively,
creating fresh Variables.
"""
@@ -206,7 +206,7 @@
else:
a = LLAbstractValue()
memo.seen[self] = a
- a.content = self.fz_content.unfreeze(memo)
+ a.content = self.fz_content.unfreeze(memo, block)
return a
def match(self, a_value, memo):
Modified: pypy/dist/pypy/jit/vlist.py
==============================================================================
--- pypy/dist/pypy/jit/vlist.py (original)
+++ pypy/dist/pypy/jit/vlist.py Wed Jan 25 13:11:59 2006
@@ -34,18 +34,13 @@
items_a = [a.freeze(memo) for a in self.items_a]
return LLVirtualList(self.T, items_a)
- def unfreeze(self, memo):
- items_a = [a.unfreeze(memo) for a in self.items_a]
+ def unfreeze(self, memo, block):
+ items_a = [a.unfreeze(memo, block) for a in self.items_a]
return LLVirtualList(self.T, items_a)
def build_runtime_container(self, builder):
items_v = [a.forcevarorconst(builder) for a in self.items_a]
- llop = LowLevelOpList(None)
- v_result = self.T.list_builder(llop, items_v)
- print 'list_builder:'
- for op in llop:
- print '\t', op
- builder.residual_operations.append(op)
+ v_result = self.T.list_builder(builder, items_v)
return v_result
# ____________________________________________________________
Modified: pypy/dist/pypy/rpython/rgenop.py
==============================================================================
--- pypy/dist/pypy/rpython/rgenop.py (original)
+++ pypy/dist/pypy/rpython/rgenop.py Wed Jan 25 13:11:59 2006
@@ -18,6 +18,9 @@
return v
def genop(block, opname, vars, RESULT_TYPE):
+ for v in vars:
+ assert isinstance(v, (flowmodel.Constant, flowmodel.Variable))
+
v = flowmodel.Variable()
v.concretetype = RESULT_TYPE
op = flowmodel.SpaceOperation(opname, vars, v)
@@ -29,6 +32,10 @@
v.concretetype = lltype.typeOf(llvalue)
return v
+def addconst(block, const):
+ assert isinstance(const, flowmodel.Constant)
+ return const
+
def closeblock1(block):
link = flowmodel.Link([], None)
block.closeblock(link)
Modified: pypy/dist/pypy/rpython/rlist.py
==============================================================================
--- pypy/dist/pypy/rpython/rlist.py (original)
+++ pypy/dist/pypy/rpython/rlist.py Wed Jan 25 13:11:59 2006
@@ -175,21 +175,25 @@
fnptr = list_repr.rtyper.annotate_helper_fn(ll_setitem_nonneg, argtypes)
self.c_setitem_nonneg = inputconst(typeOf(fnptr), fnptr)
self.c_dum_nocheck = inputconst(Void, dum_nocheck)
+ self.c_LIST = inputconst(Void, self.LIST)
- def build(self, llop, items_v):
+ def build(self, builder, items_v):
"""Make the operations that would build a list containing the
provided items."""
- # This is called by the JIT with llop.rtyper == None, so
- # llop.gendirectcall() doesn't work. Instead, we need to call
- # directly the c_newitem and c_setitem_nonneg precomputed above.
- c_list = inputconst(Void, self.LIST)
- c_len = inputconst(Signed, len(items_v))
- v_result = llop.genop('direct_call', [self.c_newlist, c_list, c_len],
- resulttype = self.LISTPTR)
+ c_list = builder.addconst(self.c_LIST)
+ c_newlist = builder.addconst(self.c_newlist)
+ c_len = builder.genconst(len(items_v))
+ v_result = builder.genop('direct_call',
+ [c_newlist, c_list, c_len],
+ self.LISTPTR)
+ c_setitem_nonneg = builder.addconst(self.c_setitem_nonneg)
+ c_dum_nocheck = builder.addconst(self.c_dum_nocheck)
for i, v in enumerate(items_v):
- llop.genop('direct_call', [self.c_setitem_nonneg,
- self.c_dum_nocheck,
- v_result, inputconst(Signed, i), v])
+ c_i = builder.genconst(i)
+ builder.genop('direct_call', [c_setitem_nonneg,
+ c_dum_nocheck,
+ v_result, c_i, v],
+ Void)
return v_result
class ListRepr(BaseListRepr):
More information about the Pypy-commit
mailing list