[pypy-svn] r78533 - in pypy/branch/jit-unroll-loops/pypy/jit/metainterp: . optimizeopt test
cfbolz at codespeak.net
cfbolz at codespeak.net
Sat Oct 30 16:59:02 CEST 2010
Author: cfbolz
Date: Sat Oct 30 16:58:59 2010
New Revision: 78533
Added:
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeutil.py
- copied, changed from r78527, pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizefindnode.py
Removed:
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizefindnode.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/specnode.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizefindnode.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_specnode.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/viewnode.py
Modified:
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/compile.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/history.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimize.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/__init__.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/rewrite.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/virtualize.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/pyjitpl.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_compile.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizebasic.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeopt.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_resume.py
pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_virtualizable.py
Log:
kill perfect specialization and specnodes
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/compile.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/compile.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/compile.py Sat Oct 30 16:58:59 2010
@@ -11,7 +11,6 @@
from pypy.jit.metainterp.history import AbstractFailDescr, BoxInt
from pypy.jit.metainterp.history import BoxPtr, BoxObj, BoxFloat, Const
from pypy.jit.metainterp import history
-from pypy.jit.metainterp.specnode import NotSpecNode, more_general_specnodes
from pypy.jit.metainterp.typesystem import llhelper, oohelper
from pypy.jit.metainterp.optimizeutil import InvalidLoop
from pypy.jit.codewriter import heaptracker
@@ -42,7 +41,6 @@
def make_loop_token(nb_args, jitdriver_sd):
loop_token = LoopToken()
- loop_token.specnodes = [prebuiltNotSpecNode] * nb_args
loop_token.outermost_jitdriver_sd = jitdriver_sd
return loop_token
@@ -82,8 +80,6 @@
return old_loop_token
if loop.preamble.operations:
- loop.token.specnodes = [prebuiltNotSpecNode] * len(loop.inputargs) # FIXME
- loop.preamble.token.specnodes = [prebuiltNotSpecNode] * len(loop.preamble.inputargs) # FIXME
send_loop_to_backend(metainterp_sd, loop, "loop")
send_loop_to_backend(metainterp_sd, loop.preamble, "entry bridge")
insert_loop_token(old_loop_tokens, loop.preamble.token)
@@ -100,13 +96,8 @@
# The following algo means "as late as possible, but before another
# loop token that would be more general and so completely mask off
# the new loop_token".
- for i in range(len(old_loop_tokens)):
- if more_general_specnodes(old_loop_tokens[i].specnodes,
- loop_token.specnodes):
- old_loop_tokens.insert(i, loop_token)
- break
- else:
- old_loop_tokens.append(loop_token)
+ # XXX do we still need a list?
+ old_loop_tokens.append(loop_token)
def send_loop_to_backend(metainterp_sd, loop, type):
globaldata = metainterp_sd.globaldata
@@ -189,13 +180,10 @@
raise metainterp_sd.ExitFrameWithExceptionRef(cpu, value)
-prebuiltNotSpecNode = NotSpecNode()
-
class TerminatingLoopToken(LoopToken):
terminating = True
def __init__(self, nargs, finishdescr):
- self.specnodes = [prebuiltNotSpecNode]*nargs
self.finishdescr = finishdescr
def make_done_loop_tokens():
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/history.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/history.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/history.py Sat Oct 30 16:58:59 2010
@@ -728,7 +728,6 @@
"""
terminating = False # see TerminatingLoopToken in compile.py
outermost_jitdriver_sd = None
- # specnodes = ...
# and more data specified by the backend when the loop is compiled
number = 0
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimize.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimize.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimize.py Sat Oct 30 16:58:59 2010
@@ -2,9 +2,7 @@
# ____________________________________________________________
-from pypy.jit.metainterp.optimizefindnode import PerfectSpecializationFinder
from pypy.jit.metainterp.optimizeopt import optimize_loop_1
-from pypy.jit.metainterp.specnode import equals_specnodes
def optimize_loop(metainterp_sd, old_loop_tokens, loop):
debug_start("jit-optimize")
@@ -16,19 +14,14 @@
def _optimize_loop(metainterp_sd, old_loop_tokens, loop):
cpu = metainterp_sd.cpu
metainterp_sd.logger_noopt.log_loop(loop.inputargs, loop.operations)
- finder = PerfectSpecializationFinder(cpu)
- finder.find_nodes_loop(loop)
- for old_loop_token in old_loop_tokens:
- if equals_specnodes(old_loop_token.specnodes, loop.token.specnodes):
- return old_loop_token
+ # XXX do we really still need a list?
+ if old_loop_tokens:
+ return old_loop_tokens[0]
optimize_loop_1(metainterp_sd, loop)
return None
# ____________________________________________________________
-from pypy.jit.metainterp.optimizefindnode import BridgeSpecializationFinder
-from pypy.jit.metainterp.optimizeopt import optimize_bridge_1
-
def optimize_bridge(metainterp_sd, old_loop_tokens, bridge):
debug_start("jit-optimize")
try:
@@ -37,15 +30,10 @@
debug_stop("jit-optimize")
def _optimize_bridge(metainterp_sd, old_loop_tokens, bridge):
- cpu = metainterp_sd.cpu
+ cpu = metainterp_sd.cpu
metainterp_sd.logger_noopt.log_loop(bridge.inputargs, bridge.operations)
- finder = BridgeSpecializationFinder(cpu)
- finder.find_nodes_bridge(bridge)
- for old_loop_token in old_loop_tokens:
- if finder.bridge_matches(old_loop_token.specnodes):
- bridge.operations[-1].setdescr(old_loop_token) # patch jump target
- optimize_bridge_1(metainterp_sd, bridge)
- return old_loop_token
+ if old_loop_tokens:
+ return old_loop_tokens[0]
return None
# ____________________________________________________________
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/__init__.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/__init__.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/__init__.py Sat Oct 30 16:58:59 2010
@@ -8,10 +8,7 @@
from pypy.jit.metainterp.optimizeopt.unroll import OptUnroll
def optimize_loop_1(metainterp_sd, loop, not_a_bridge=True):
- """Optimize loop.operations to make it match the input of loop.specnodes
- and to remove internal overheadish operations. Note that loop.specnodes
- must be applicable to the loop; you will probably get an AssertionError
- if not.
+ """Optimize loop.operations to remove internal overheadish operations.
"""
optimizations = [OptIntBounds(),
OptRewrite(),
@@ -26,7 +23,5 @@
optimizer.propagate_all_forward()
def optimize_bridge_1(metainterp_sd, bridge):
- """The same, but for a bridge. The only difference is that we don't
- expect 'specnodes' on the bridge.
- """
+ """The same, but for a bridge. """
optimize_loop_1(metainterp_sd, bridge, False)
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/rewrite.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/rewrite.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/rewrite.py Sat Oct 30 16:58:59 2010
@@ -207,9 +207,6 @@
assert isinstance(expectedclassbox, Const)
realclassbox = value.get_constant_class(self.optimizer.cpu)
if realclassbox is not None:
- # the following assert should always be true for now,
- # because invalid loops that would fail it are detected
- # earlier, in optimizefindnode.py.
if realclassbox.same_constant(expectedclassbox):
return
raise InvalidLoop
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/virtualize.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/virtualize.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/optimizeopt/virtualize.py Sat Oct 30 16:58:59 2010
@@ -1,9 +1,4 @@
from pypy.jit.metainterp.history import Const, ConstInt
-from pypy.jit.metainterp.specnode import SpecNode, NotSpecNode, ConstantSpecNode
-from pypy.jit.metainterp.specnode import AbstractVirtualStructSpecNode
-from pypy.jit.metainterp.specnode import VirtualInstanceSpecNode
-from pypy.jit.metainterp.specnode import VirtualArraySpecNode
-from pypy.jit.metainterp.specnode import VirtualStructSpecNode
from pypy.jit.metainterp.resoperation import rop, ResOperation
from pypy.jit.metainterp.optimizeutil import _findall, sort_descrs
from pypy.jit.metainterp.optimizeutil import descrlist_dict
@@ -228,79 +223,9 @@
boxes.append(self.box)
-class __extend__(SpecNode):
- def setup_virtual_node(self, optimizer, box, newinputargs):
- raise NotImplementedError
- def teardown_virtual_node(self, optimizer, value, newexitargs):
- raise NotImplementedError
-
-class __extend__(NotSpecNode):
- def setup_virtual_node(self, optimizer, box, newinputargs):
- newinputargs.append(box)
- def teardown_virtual_node(self, optimizer, value, newexitargs):
- newexitargs.append(value.force_box())
-
-class __extend__(ConstantSpecNode):
- def setup_virtual_node(self, optimizer, box, newinputargs):
- optimizer.make_constant(box, self.constbox)
- def teardown_virtual_node(self, optimizer, value, newexitargs):
- pass
-
-class __extend__(AbstractVirtualStructSpecNode):
- def setup_virtual_node(self, optimizer, box, newinputargs):
- vvalue = self._setup_virtual_node_1(optimizer, box)
- for ofs, subspecnode in self.fields:
- subbox = optimizer.new_box(ofs)
- subspecnode.setup_virtual_node(optimizer, subbox, newinputargs)
- vvaluefield = optimizer.getvalue(subbox)
- vvalue.setfield(ofs, vvaluefield)
- def _setup_virtual_node_1(self, optimizer, box):
- raise NotImplementedError
- def teardown_virtual_node(self, optimizer, value, newexitargs):
- assert value.is_virtual()
- for ofs, subspecnode in self.fields:
- subvalue = value.getfield(ofs, optimizer.new_const(ofs))
- subspecnode.teardown_virtual_node(optimizer, subvalue, newexitargs)
-
-class __extend__(VirtualInstanceSpecNode):
- def _setup_virtual_node_1(self, optimizer, box):
- return optimizer.make_virtual(self.known_class, box)
-
-class __extend__(VirtualStructSpecNode):
- def _setup_virtual_node_1(self, optimizer, box):
- return optimizer.make_vstruct(self.typedescr, box)
-
-class __extend__(VirtualArraySpecNode):
- def setup_virtual_node(self, optimizer, box, newinputargs):
- vvalue = optimizer.make_varray(self.arraydescr, len(self.items), box)
- for index in range(len(self.items)):
- subbox = optimizer.new_box_item(self.arraydescr)
- subspecnode = self.items[index]
- subspecnode.setup_virtual_node(optimizer, subbox, newinputargs)
- vvalueitem = optimizer.getvalue(subbox)
- vvalue.setitem(index, vvalueitem)
- def teardown_virtual_node(self, optimizer, value, newexitargs):
- assert value.is_virtual()
- for index in range(len(self.items)):
- subvalue = value.getitem(index)
- subspecnode = self.items[index]
- subspecnode.teardown_virtual_node(optimizer, subvalue, newexitargs)
-
class OptVirtualize(optimizer.Optimization):
"Virtualize objects until they escape."
- def setup(self, not_a_bridge):
- if not not_a_bridge:
- return
-
- inputargs = self.optimizer.loop.inputargs
- specnodes = self.optimizer.loop.token.specnodes
- assert len(inputargs) == len(specnodes)
- newinputargs = []
- for i in range(len(inputargs)):
- specnodes[i].setup_virtual_node(self, inputargs[i], newinputargs)
- self.optimizer.loop.inputargs = newinputargs
-
def make_virtual(self, known_class, box, source_op=None):
vvalue = VirtualValue(self.optimizer, known_class, box, source_op)
self.make_equal_to(box, vvalue)
@@ -316,21 +241,6 @@
self.make_equal_to(box, vvalue)
return vvalue
- def optimize_JUMP(self, op):
- self.emit_operation(op) # FIXME
- return
- orgop = self.optimizer.loop.operations[-1]
- exitargs = []
- target_loop_token = orgop.getdescr()
- assert isinstance(target_loop_token, LoopToken)
- specnodes = target_loop_token.specnodes
- assert op.numargs() == len(specnodes)
- for i in range(len(specnodes)):
- value = self.getvalue(op.getarg(i))
- specnodes[i].teardown_virtual_node(self, value, exitargs)
- op = op.copy_and_change(op.getopnum(), args=exitargs[:])
- self.emit_operation(op)
-
def optimize_VIRTUAL_REF(self, op):
indexbox = op.getarg(1)
#
@@ -377,7 +287,6 @@
def optimize_GETFIELD_GC(self, op):
value = self.getvalue(op.getarg(0))
if value.is_virtual():
- # optimizefindnode should ensure that fieldvalue is found
assert isinstance(value, AbstractVirtualValue)
fieldvalue = value.getfield(op.getdescr(), None)
if fieldvalue is None:
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/pyjitpl.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/pyjitpl.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/pyjitpl.py Sat Oct 30 16:58:59 2010
@@ -1746,8 +1746,7 @@
def designate_target_loop(self, gmp):
loop_token = gmp.target_loop_token
num_green_args = self.jitdriver_sd.num_green_args
- residual_args = self.get_residual_args(loop_token.specnodes,
- gmp.argboxes[num_green_args:])
+ residual_args = gmp.argboxes[num_green_args:]
history.set_future_values(self.cpu, residual_args)
return loop_token
@@ -1854,16 +1853,6 @@
if target_loop_token is not loop_tokens[0]:
compile.giveup()
- def get_residual_args(self, specnodes, args):
- if specnodes is None: # it is None only for tests
- return args
- assert len(specnodes) == len(args)
- expanded_args = []
- for i in range(len(specnodes)):
- specnode = specnodes[i]
- specnode.extract_runtime_data(self.cpu, args[i], expanded_args)
- return expanded_args
-
@specialize.arg(1)
def initialize_original_boxes(self, jitdriver_sd, *args):
original_boxes = []
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_compile.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_compile.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_compile.py Sat Oct 30 16:58:59 2010
@@ -1,32 +1,29 @@
from pypy.jit.metainterp.history import LoopToken, ConstInt, History, Stats
from pypy.jit.metainterp.history import BoxInt, INT
-from pypy.jit.metainterp.specnode import NotSpecNode, ConstantSpecNode
from pypy.jit.metainterp.compile import insert_loop_token, compile_new_loop
from pypy.jit.metainterp.compile import ResumeGuardDescr
from pypy.jit.metainterp.compile import ResumeGuardCountersInt
from pypy.jit.metainterp.compile import compile_tmp_callback
from pypy.jit.metainterp import optimize_nopspec, jitprof, typesystem, compile
-from pypy.jit.metainterp.test.test_optimizefindnode import LLtypeMixin
+from pypy.jit.metainterp.test.test_optimizeutil import LLtypeMixin
from pypy.jit.tool.oparser import parse
def test_insert_loop_token():
+ # XXX this test is a bit useless now that there are no specnodes
lst = []
#
tok1 = LoopToken()
- tok1.specnodes = [NotSpecNode()]
insert_loop_token(lst, tok1)
assert lst == [tok1]
#
tok2 = LoopToken()
- tok2.specnodes = [ConstantSpecNode(ConstInt(8))]
insert_loop_token(lst, tok2)
- assert lst == [tok2, tok1]
+ assert lst == [tok1, tok2]
#
tok3 = LoopToken()
- tok3.specnodes = [ConstantSpecNode(ConstInt(-13))]
insert_loop_token(lst, tok3)
- assert lst == [tok2, tok3, tok1]
+ assert lst == [tok1, tok2, tok3]
class FakeCPU:
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizebasic.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizebasic.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizebasic.py Sat Oct 30 16:58:59 2010
@@ -1,9 +1,8 @@
import py
from pypy.rlib.objectmodel import instantiate
-from pypy.jit.metainterp.test.test_optimizefindnode import (LLtypeMixin,
- #OOtypeMixin,
- BaseTest)
-from pypy.jit.metainterp.optimizefindnode import PerfectSpecializationFinder
+from pypy.jit.metainterp.test.test_optimizeutil import (LLtypeMixin,
+ #OOtypeMixin,
+ BaseTest)
import pypy.jit.metainterp.optimizeopt.optimizer as optimizeopt
import pypy.jit.metainterp.optimizeopt.virtualize as virtualize
from pypy.jit.metainterp.optimizeutil import InvalidLoop
@@ -244,9 +243,8 @@
assert equaloplists(optimized.operations,
expected.operations, False, remap)
- def optimize_loop(self, ops, spectext, optops, checkspecnodes=True):
+ def optimize_loop(self, ops, spectext, optops):
loop = self.parse(ops)
- loop.token.specnodes = self.unpack_specnodes(spectext)
#
self.loop = loop
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
@@ -858,7 +856,7 @@
"""
py.test.skip("XXX")
self.optimize_loop(ops, 'Not, Virtual(node_vtable, floatdescr=Not)',
- expected, checkspecnodes=False)
+ expected)
def test_virtual_2(self):
ops = """
@@ -913,7 +911,7 @@
self.optimize_loop(ops, '''Virtual(node_vtable),
Virtual(node_vtable),
Not''',
- expected, checkspecnodes=False)
+ expected)
#
# to be complete, we also check the no-opt case where most comparisons
# are not removed. The exact set of comparisons removed depends on
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeopt.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeopt.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeopt.py Sat Oct 30 16:58:59 2010
@@ -1,9 +1,8 @@
import py
from pypy.rlib.objectmodel import instantiate
-from pypy.jit.metainterp.test.test_optimizefindnode import (LLtypeMixin,
- #OOtypeMixin,
- BaseTest)
-from pypy.jit.metainterp.optimizefindnode import PerfectSpecializationFinder
+from pypy.jit.metainterp.test.test_optimizeutil import (LLtypeMixin,
+ #OOtypeMixin,
+ BaseTest)
import pypy.jit.metainterp.optimizeopt.optimizer as optimizeopt
import pypy.jit.metainterp.optimizeopt.virtualize as virtualize
from pypy.jit.metainterp.optimizeopt import optimize_loop_1
@@ -67,7 +66,6 @@
def optimize_loop(self, ops, spectext, optops, expected_preamble=None):
loop = self.parse(ops)
- loop.token.specnodes = self.unpack_specnodes(spectext)
#
self.loop = loop
loop.preamble = TreeLoop('preamble')
Copied: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeutil.py (from r78527, pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizefindnode.py)
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizefindnode.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_optimizeutil.py Sat Oct 30 16:58:59 2010
@@ -8,17 +8,10 @@
from pypy.jit.metainterp.history import (BoxInt, BoxPtr, ConstInt, ConstPtr,
Const, TreeLoop, BoxObj,
ConstObj, AbstractDescr)
-from pypy.jit.metainterp.optimizefindnode import PerfectSpecializationFinder
-from pypy.jit.metainterp.optimizefindnode import BridgeSpecializationFinder
from pypy.jit.metainterp.optimizeutil import sort_descrs, InvalidLoop
-from pypy.jit.metainterp.specnode import NotSpecNode, prebuiltNotSpecNode
-from pypy.jit.metainterp.specnode import VirtualInstanceSpecNode
-from pypy.jit.metainterp.specnode import VirtualArraySpecNode
-from pypy.jit.metainterp.specnode import VirtualStructSpecNode
-from pypy.jit.metainterp.specnode import ConstantSpecNode
from pypy.jit.codewriter.effectinfo import EffectInfo
from pypy.jit.codewriter.heaptracker import register_known_gctype, adr2int
-from pypy.jit.metainterp.test.oparser import parse
+from pypy.jit.tool.oparser import parse
def test_sort_descrs():
class PseudoDescr(AbstractDescr):
@@ -245,956 +238,5 @@
boxkinds=boxkinds,
invent_fail_descr=self.invent_fail_descr)
- def unpack_specnodes(self, text):
- #
- def constclass(cls_vtable):
- if self.type_system == 'lltype':
- return ConstInt(adr2int(llmemory.cast_ptr_to_adr(cls_vtable)))
- else:
- return ConstObj(ootype.cast_to_object(cls_vtable))
- def constant(value):
- if isinstance(lltype.typeOf(value), lltype.Ptr):
- return ConstPtr(value)
- elif isinstance(ootype.typeOf(value), ootype.OOType):
- return ConstObj(ootype.cast_to_object(value))
- else:
- return ConstInt(value)
-
- def parsefields(kwds_fields):
- fields = []
- for key, value in kwds_fields.items():
- fields.append((self.namespace[key], value))
- fields.sort(key = lambda (x, _): x.sort_key())
- return fields
- def makeConstant(value):
- return ConstantSpecNode(constant(value))
- def makeVirtual(cls_vtable, **kwds_fields):
- fields = parsefields(kwds_fields)
- return VirtualInstanceSpecNode(constclass(cls_vtable), fields)
- def makeVirtualArray(arraydescr, *items):
- return VirtualArraySpecNode(arraydescr, items)
- def makeVirtualStruct(typedescr, **kwds_fields):
- fields = parsefields(kwds_fields)
- return VirtualStructSpecNode(typedescr, fields)
- #
- context = {'Not': prebuiltNotSpecNode,
- 'Constant': makeConstant,
- 'Virtual': makeVirtual,
- 'VArray': makeVirtualArray,
- 'VStruct': makeVirtualStruct}
- lst = eval('[' + text + ']', self.namespace, context)
- return lst
-
- def check_specnodes(self, specnodes, text):
- lst = self.unpack_specnodes(text)
- assert len(specnodes) == len(lst)
- for x, y in zip(specnodes, lst):
- assert x.equals(y, ge=False)
- return True
-
# ____________________________________________________________
-class BaseTestOptimizeFindNode(BaseTest):
-
- def find_nodes(self, ops, spectext, boxkinds=None):
- assert boxkinds is None or isinstance(boxkinds, dict)
- loop = self.parse(ops, boxkinds=boxkinds)
- perfect_specialization_finder = PerfectSpecializationFinder(self.cpu)
- perfect_specialization_finder.find_nodes_loop(loop)
- self.check_specnodes(loop.token.specnodes, spectext)
- return (loop.getboxes(), perfect_specialization_finder.getnode)
-
- def test_find_nodes_simple(self):
- ops = """
- [i]
- i0 = int_sub(i, 1)
- guard_value(i0, 0) [i0]
- jump(i0)
- """
- boxes, getnode = self.find_nodes(ops, 'Not')
- assert getnode(boxes.i).fromstart
- assert not getnode(boxes.i0).fromstart
-
- def test_find_nodes_non_escape(self):
- ops = """
- [p0]
- p1 = getfield_gc(p0, descr=nextdescr)
- i0 = getfield_gc(p1, descr=valuedescr)
- i1 = int_sub(i0, 1)
- p2 = getfield_gc(p0, descr=nextdescr)
- setfield_gc(p2, i1, descr=valuedescr)
- p3 = new_with_vtable(ConstClass(node_vtable))
- jump(p3)
- """
- boxes, getnode = self.find_nodes(ops,
- 'Virtual(node_vtable, nextdescr=Not)')
- assert not getnode(boxes.p0).escaped
- assert getnode(boxes.p1).escaped
- assert getnode(boxes.p2).escaped
- assert getnode(boxes.p0).fromstart
- assert getnode(boxes.p1).fromstart
- assert getnode(boxes.p2).fromstart
-
- def test_find_nodes_escape(self):
- ops = """
- [p0]
- p1 = getfield_gc(p0, descr=nextdescr)
- p2 = getfield_gc(p1, descr=nextdescr)
- i0 = getfield_gc(p2, descr=valuedescr)
- i1 = int_sub(i0, 1)
- escape(p1)
- p3 = getfield_gc(p0, descr=nextdescr)
- setfield_gc(p3, i1, descr=valuedescr)
- p4 = getfield_gc(p1, descr=nextdescr)
- setfield_gc(p4, i1, descr=valuedescr)
- p5 = new_with_vtable(ConstClass(node_vtable))
- jump(p5)
- """
- boxes, getnode = self.find_nodes(ops,
- 'Virtual(node_vtable, nextdescr=Not)')
- assert not getnode(boxes.p0).escaped
- assert getnode(boxes.p1).escaped
- assert getnode(boxes.p2).escaped # forced by p1
- assert getnode(boxes.p3).escaped # forced because p3 == p1
- assert getnode(boxes.p4).escaped # forced by p1
- assert getnode(boxes.p0).fromstart
- assert getnode(boxes.p1).fromstart
- assert getnode(boxes.p2).fromstart
- assert getnode(boxes.p3).fromstart
- assert not getnode(boxes.p4).fromstart
-
- def test_find_nodes_new_1(self):
- ops = """
- [p1]
- p2 = new_with_vtable(ConstClass(node_vtable))
- jump(p2)
- """
- boxes, getnode = self.find_nodes(ops, 'Virtual(node_vtable)')
-
- boxp1 = getnode(boxes.p1)
- boxp2 = getnode(boxes.p2)
- assert not boxp1.escaped
- assert not boxp2.escaped
-
- assert not boxp1.origfields
- assert not boxp1.curfields
- assert not boxp2.origfields
- assert not boxp2.curfields
-
- assert boxp1.fromstart
- assert not boxp2.fromstart
-
- assert boxp1.knownclsbox is None
- assert boxp2.knownclsbox.getaddr() == self.node_vtable_adr
-
- def test_find_nodes_new_2(self):
- ops = """
- [i1, p1]
- p2 = new_with_vtable(ConstClass(node_vtable))
- p3 = new_with_vtable(ConstClass(node_vtable2))
- setfield_gc(p2, p3, descr=nextdescr)
- setfield_gc(p3, i1, descr=valuedescr)
- jump(i1, p2)
- """
- self.find_nodes(ops,
- '''Not,
- Virtual(node_vtable,
- nextdescr=Virtual(node_vtable2,
- valuedescr=Not))''')
-
- def test_find_nodes_new_3(self):
- ops = """
- [sum, p1]
- guard_class(p1, ConstClass(node_vtable)) []
- i1 = getfield_gc(p1, descr=valuedescr)
- i2 = int_sub(i1, 1)
- sum2 = int_add(sum, i1)
- p2 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p2, i2, descr=valuedescr)
- p3 = new_with_vtable(ConstClass(node_vtable2))
- setfield_gc(p2, p3, descr=nextdescr)
- jump(sum2, p2)
- """
- boxes, getnode = self.find_nodes(
- ops,
- '''Not,
- Virtual(node_vtable,
- valuedescr=Not,
- nextdescr=Virtual(node_vtable2))''',
- boxkinds={'sum': BoxInt, 'sum2': BoxInt})
- assert getnode(boxes.sum) is not getnode(boxes.sum2)
- assert getnode(boxes.p1) is not getnode(boxes.p2)
-
- boxp1 = getnode(boxes.p1)
- boxp2 = getnode(boxes.p2)
- boxp3 = getnode(boxes.p3)
- assert not boxp1.escaped
- assert not boxp2.escaped
- assert not boxp3.escaped
-
- assert not boxp1.curfields
- assert boxp1.origfields[self.valuedescr] is getnode(boxes.i1)
- assert not boxp2.origfields
- assert boxp2.curfields[self.nextdescr] is boxp3
-
- assert boxp1.fromstart
- assert not boxp2.fromstart
- assert not boxp3.fromstart
-
- assert boxp2.knownclsbox.getaddr() == self.node_vtable_adr
- assert boxp3.knownclsbox.getaddr() == self.node_vtable_adr2
-
- def test_find_nodes_new_aliasing_0(self):
- ops = """
- [p1, p2]
- p3 = new_with_vtable(ConstClass(node_vtable))
- jump(p3, p3)
- """
- # both p1 and p2 must be NotSpecNodes; it's not possible to pass
- # the same Virtual both in p1 and p2 (at least so far).
- self.find_nodes(ops, 'Not, Not')
-
- def test_find_nodes_new_aliasing_1(self):
- ops = """
- [sum, p1]
- guard_class(p1, ConstClass(node_vtable)) []
- p3 = getfield_gc(p1, descr=nextdescr)
- guard_class(p3, ConstClass(node_vtable)) []
- i1 = getfield_gc(p1, descr=valuedescr)
- i2 = int_sub(i1, 1)
- sum2 = int_add(sum, i1)
- p2 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p2, i2, descr=valuedescr)
- setfield_gc(p2, p2, descr=nextdescr)
- jump(sum2, p2)
- """
- # the issue is the cycle "p2->p2", which cannot be represented
- # with SpecNodes so far
- self.find_nodes(ops, 'Not, Not',
- boxkinds={'sum': BoxInt, 'sum2': BoxInt})
-
- def test_find_nodes_new_aliasing_2(self):
- ops = """
- [p1, p2]
- escape(p2)
- p3 = new_with_vtable(ConstClass(node_vtable))
- jump(p3, p3)
- """
- # both p1 and p2 must be NotSpecNodes; it's not possible to pass
- # in p1 a Virtual and not in p2, as they both come from the same p3.
- self.find_nodes(ops, 'Not, Not')
-
- def test_find_nodes_new_mismatch(self):
- ops = """
- [p1]
- guard_class(p1, ConstClass(node_vtable)) []
- p2 = new_with_vtable(ConstClass(node_vtable2))
- jump(p2)
- """
- # this is not a valid loop at all, because of the mismatch
- # between the produced and the consumed class.
- py.test.raises(InvalidLoop, self.find_nodes, ops, None)
-
- def test_find_nodes_new_aliasing_mismatch(self):
- ops = """
- [p0, p1]
- guard_class(p0, ConstClass(node_vtable)) []
- guard_class(p1, ConstClass(node_vtable2)) []
- p2 = new_with_vtable(ConstClass(node_vtable2))
- jump(p2, p2)
- """
- # this is also not really a valid loop, but it's not detected
- # because p2 is passed more than once in the jump().
- self.find_nodes(ops, 'Not, Not')
-
- def test_find_nodes_new_escapes(self):
- ops = """
- [p0]
- escape(p0)
- p1 = new_with_vtable(ConstClass(node_vtable))
- jump(p1)
- """
- self.find_nodes(ops, 'Not')
-
- def test_find_nodes_new_unused(self):
- ops = """
- [p0]
- p1 = new_with_vtable(ConstClass(node_vtable))
- p2 = new_with_vtable(ConstClass(node_vtable))
- p3 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, p2, descr=nextdescr)
- setfield_gc(p2, p3, descr=nextdescr)
- jump(p1)
- """
- self.find_nodes(ops, '''
- Virtual(node_vtable,
- nextdescr=Virtual(node_vtable,
- nextdescr=Virtual(node_vtable)))''')
-
- def test_find_nodes_ptr_eq(self):
- ops = """
- [p3, p4, p2]
- p0 = new_with_vtable(ConstClass(node_vtable))
- p1 = new_with_vtable(ConstClass(node_vtable))
- guard_nonnull(p0) []
- i3 = ptr_ne(p0, NULL)
- guard_true(i3) []
- i4 = ptr_eq(p0, NULL)
- guard_false(i4) []
- i5 = ptr_ne(NULL, p0)
- guard_true(i5) []
- i6 = ptr_eq(NULL, p0)
- guard_false(i6) []
- i7 = ptr_ne(p0, p1)
- guard_true(i7) []
- i8 = ptr_eq(p0, p1)
- guard_false(i8) []
- i9 = ptr_ne(p0, p2)
- guard_true(i9) []
- i10 = ptr_eq(p0, p2)
- guard_false(i10) []
- i11 = ptr_ne(p2, p1)
- guard_true(i11) []
- i12 = ptr_eq(p2, p1)
- guard_false(i12) []
- jump(p0, p1, p2)
- """
- self.find_nodes(ops, '''Virtual(node_vtable),
- Virtual(node_vtable),
- Not''')
-
- def test_find_nodes_call(self):
- ops = """
- [i0, p2]
- p0 = new_with_vtable(ConstClass(node_vtable))
- i1 = call_pure(i0, p0) # forces p0 to not be virtual
- jump(i1, p0)
- """
- self.find_nodes(ops, 'Not, Not')
-
- def test_find_nodes_default_field(self):
- ops = """
- [p0]
- i0 = getfield_gc(p0, descr=valuedescr)
- guard_value(i0, 5) []
- p1 = new_with_vtable(ConstClass(node_vtable))
- # the field 'value' has its default value of 0
- jump(p1)
- """
- # The answer must contain the 'value' field, because otherwise
- # we might get incorrect results: when tracing, i0 was 5.
- self.find_nodes(ops, 'Virtual(node_vtable, valuedescr=Not)')
-
- def test_find_nodes_nonvirtual_guard_class(self):
- ops = """
- [p1]
- guard_class(p1, ConstClass(node_vtable)) [p1]
- jump(p1)
- """
- self.find_nodes(ops, 'Not')
-
- def test_find_nodes_p12_simple(self):
- ops = """
- [p1]
- i3 = getfield_gc(p1, descr=valuedescr)
- escape(i3)
- jump(p1)
- """
- self.find_nodes(ops, 'Not')
-
- def test_find_nodes_p123_simple(self):
- ops = """
- [i1, p2, p3]
- i3 = getfield_gc(p3, descr=valuedescr)
- escape(i3)
- p1 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, i1, descr=valuedescr)
- jump(i1, p1, p2)
- """
- # We cannot track virtuals that survive for more than two iterations.
- self.find_nodes(ops, 'Not, Not, Not')
-
- def test_find_nodes_p1234_simple(self):
- ops = """
- [i1, p2, p3, p4]
- i4 = getfield_gc(p4, descr=valuedescr)
- escape(i4)
- p1 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, i1, descr=valuedescr)
- jump(i1, p1, p2, p3)
- """
- # We cannot track virtuals that survive for more than two iterations.
- self.find_nodes(ops, 'Not, Not, Not, Not')
-
- def test_find_nodes_p123_guard_class(self):
- ops = """
- [i1, p2, p3]
- guard_class(p3, ConstClass(node_vtable)) [i1, p2, p3]
- i3 = getfield_gc(p3, descr=valuedescr)
- escape(i3)
- p1 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, i1, descr=valuedescr)
- jump(i1, p1, p2)
- """
- # We cannot track virtuals that survive for more than two iterations.
- self.find_nodes(ops, 'Not, Not, Not')
-
- def test_find_nodes_p123_rec(self):
- ops = """
- [i1, p2, p0d]
- p3 = getfield_gc(p0d, descr=nextdescr)
- i3 = getfield_gc(p3, descr=valuedescr)
- escape(i3)
- p1 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, i1, descr=valuedescr)
- p0c = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p0c, p2, descr=nextdescr)
- jump(i1, p1, p0c)
- """
- # We cannot track virtuals that survive for more than two iterations.
- self.find_nodes(ops, '''Not,
- Not,
- Virtual(node_vtable, nextdescr=Not)''')
-
- def test_find_nodes_setfield_bug(self):
- ops = """
- [p1, p2]
- escape(p1)
- setfield_gc(p1, p2, descr=nextdescr)
- p3 = new_with_vtable(ConstClass(node_vtable))
- jump(p1, p3)
- """
- self.find_nodes(ops, 'Not, Not')
-
- def test_find_nodes_array_virtual_1(self):
- ops = """
- [i1, p2]
- i2 = getarrayitem_gc(p2, 1, descr=arraydescr)
- escape(i2)
- p3 = new_array(3, descr=arraydescr)
- setarrayitem_gc(p3, 1, i1, descr=arraydescr)
- jump(i1, p3)
- """
- self.find_nodes(ops, 'Not, VArray(arraydescr, Not, Not, Not)')
-
- def test_find_nodes_array_virtual_2(self):
- ops = """
- [i1, p2]
- i2 = arraylen_gc(p2, descr=arraydescr)
- escape(i2)
- p3 = new_array(3, descr=arraydescr)
- setarrayitem_gc(p3, 1, i1, descr=arraydescr)
- jump(i1, p3)
- """
- self.find_nodes(ops, 'Not, VArray(arraydescr, Not, Not, Not)')
-
- def test_find_nodes_array_virtual_3(self):
- ops = """
- [pvalue1, p2]
- pvalue2 = new_with_vtable(ConstClass(node_vtable2))
- ps2 = getarrayitem_gc(p2, 1, descr=arraydescr)
- setfield_gc(ps2, pvalue2, descr=nextdescr)
- ps3 = getarrayitem_gc(p2, 1, descr=arraydescr)
- pvalue3 = getfield_gc(ps3, descr=nextdescr)
- ps1 = new_with_vtable(ConstClass(node_vtable))
- p3 = new_array(3, descr=arraydescr)
- setarrayitem_gc(p3, 1, ps1, descr=arraydescr)
- jump(pvalue3, p3)
- """
- self.find_nodes(ops, 'Virtual(node_vtable2), VArray(arraydescr, Not, Virtual(node_vtable), Not)')
-
- def test_find_nodes_array_virtual_empty(self):
- ops = """
- [i1, p2]
- p3 = new_array(3, descr=arraydescr)
- jump(i1, p3)
- """
- self.find_nodes(ops, 'Not, VArray(arraydescr, Not, Not, Not)')
-
- def test_find_nodes_array_nonvirtual_1(self):
- ops = """
- [i1, p2]
- i2 = getarrayitem_gc(p2, i1, descr=arraydescr)
- escape(i2)
- p3 = new_array(4, descr=arraydescr)
- setarrayitem_gc(p3, i1, i2, descr=arraydescr)
- jump(i1, p3)
- """
- # Does not work because of the variable index, 'i1'.
- self.find_nodes(ops, 'Not, Not')
-
- def test_find_nodes_array_forced_1(self):
- ops = """
- [p1, i1]
- p2 = new_array(1, descr=arraydescr)
- setarrayitem_gc(p2, 0, p1, descr=arraydescr)
- p3 = getarrayitem_gc(p2, i1, descr=arraydescr)
- p4 = new_with_vtable(ConstClass(node_vtable))
- jump(p4, i1)
- """
- # escapes because getarrayitem_gc uses a non-constant index
- self.find_nodes(ops, 'Not, Not')
-
- def test_find_nodes_arrayitem_forced(self):
- ops = """
- [p1]
- p2 = new_array(1, descr=arraydescr)
- escape(p2)
- p4 = new_with_vtable(ConstClass(node_vtable))
- setarrayitem_gc(p2, 0, p4, descr=arraydescr)
- jump(p4)
- """
- self.find_nodes(ops, 'Not')
-
- def test_find_nodes_struct_virtual_1(self):
- ops = """
- [i1, p2]
- i2 = getfield_gc(p2, descr=adescr)
- escape(i2)
- p3 = new(descr=ssize)
- setfield_gc(p3, i1, descr=adescr)
- jump(i1, p3)
- """
- self.find_nodes(ops, 'Not, VStruct(ssize, adescr=Not)')
-
- def test_find_nodes_struct_nonvirtual_1(self):
- ops = """
- [i1, p2]
- i2 = getfield_gc(p2, descr=adescr)
- escape(p2)
- p3 = new(descr=ssize)
- setfield_gc(p3, i1, descr=adescr)
- jump(i1, p3)
- """
- self.find_nodes(ops, 'Not, Not')
-
- def test_find_nodes_guard_value_constant(self):
- ops = """
- [p1]
- guard_value(p1, ConstPtr(myptr)) []
- jump(ConstPtr(myptr))
- """
- self.find_nodes(ops, 'Constant(myptr)')
-
- def test_find_nodes_guard_value_constant_mismatch(self):
- ops = """
- [p1]
- guard_value(p1, ConstPtr(myptr2)) []
- jump(ConstPtr(myptr))
- """
- py.test.raises(InvalidLoop, self.find_nodes, ops, None)
-
- def test_find_nodes_guard_value_escaping_constant(self):
- ops = """
- [p1]
- escape(p1)
- guard_value(p1, ConstPtr(myptr)) []
- jump(ConstPtr(myptr))
- """
- self.find_nodes(ops, 'Constant(myptr)')
-
- def test_find_nodes_guard_value_same_as_constant(self):
- ops = """
- [p1]
- guard_value(p1, ConstPtr(myptr)) []
- p2 = same_as(ConstPtr(myptr))
- jump(p2)
- """
- self.find_nodes(ops, 'Constant(myptr)')
-
- def test_find_nodes_store_into_loop_constant_1(self):
- ops = """
- [i0, p1, p4]
- p2 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, p2, descr=nextdescr)
- jump(i0, p1, p2)
- """
- self.find_nodes(ops, 'Not, Not, Not')
-
- def test_find_nodes_store_into_loop_constant_2(self):
- ops = """
- [i0, p4, p1]
- p2 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, p2, descr=nextdescr)
- jump(i0, p2, p1)
- """
- self.find_nodes(ops, 'Not, Not, Not')
-
- def test_find_nodes_store_into_loop_constant_3(self):
- ops = """
- [i0, p1]
- p2 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, p2, descr=nextdescr)
- call(i0)
- jump(i0, p1)
- """
- self.find_nodes(ops, 'Not, Not')
-
- def test_find_nodes_arithmetic_propagation_bug_0(self):
- ops = """
- [p1]
- i1 = getarrayitem_gc(p1, 0, descr=arraydescr)
- escape(i1)
- i2 = int_add(0, 1)
- p2 = new_array(i2, descr=arraydescr)
- i3 = escape()
- setarrayitem_gc(p2, 0, i3, descr=arraydescr)
- jump(p2)
- """
- self.find_nodes(ops, 'VArray(arraydescr, Not)')
-
- def test_find_nodes_arithmetic_propagation_bug_1(self):
- ops = """
- [p1]
- i1 = getarrayitem_gc(p1, 0, descr=arraydescr)
- escape(i1)
- i2 = same_as(1)
- p2 = new_array(i2, descr=arraydescr)
- setarrayitem_gc(p2, 0, 5)
- jump(p2)
- """
- self.find_nodes(ops, 'VArray(arraydescr, Not)')
-
- def test_find_nodes_arithmetic_propagation_bug_2(self):
- ops = """
- [p1]
- i0 = int_sub(17, 17)
- i1 = getarrayitem_gc(p1, i0, descr=arraydescr)
- escape(i1)
- i2 = int_add(0, 1)
- p2 = new_array(i2, descr=arraydescr)
- i3 = escape()
- setarrayitem_gc(p2, i0, i3, descr=arraydescr)
- jump(p2)
- """
- self.find_nodes(ops, 'VArray(arraydescr, Not)')
-
- def test_find_nodes_arithmetic_propagation_bug_3(self):
- ops = """
- [p1]
- i1 = getarrayitem_gc(p1, 0, descr=arraydescr)
- escape(i1)
- p3 = new_array(1, descr=arraydescr)
- i2 = arraylen_gc(p3, descr=arraydescr)
- p2 = new_array(i2, descr=arraydescr)
- i3 = escape()
- setarrayitem_gc(p2, 0, i3, descr=arraydescr)
- jump(p2)
- """
- self.find_nodes(ops, 'VArray(arraydescr, Not)')
-
- def test_find_nodes_bug_1(self):
- ops = """
- [p12]
- guard_nonnull(p12) []
- guard_class(p12, ConstClass(node_vtable)) []
- guard_class(p12, ConstClass(node_vtable)) []
- i22 = getfield_gc_pure(p12, descr=valuedescr)
- escape(i22)
- guard_nonnull(p12) []
- guard_class(p12, ConstClass(node_vtable)) []
- guard_class(p12, ConstClass(node_vtable)) []
- i29 = getfield_gc_pure(p12, descr=valuedescr)
- i31 = int_add_ovf(i29, 1)
- guard_no_overflow() []
- p33 = new_with_vtable(ConstClass(node_vtable)) # NODE
- setfield_gc(p33, i31, descr=valuedescr)
- #
- p35 = new_array(1, descr=arraydescr3) # Array(NODE)
- setarrayitem_gc(p35, 0, p33, descr=arraydescr3)
- p38 = new_with_vtable(ConstClass(u_vtable)) # U
- setfield_gc(p38, p35, descr=onedescr)
- guard_nonnull(p38) []
- guard_nonnull(p38) []
- guard_class(p38, ConstClass(u_vtable)) []
- p42 = getfield_gc(p38, descr=onedescr) # Array(NODE)
- i43 = arraylen_gc(p42, descr=arraydescr3)
- i45 = int_sub(i43, 0)
- p46 = new(descr=tsize) # T
- setfield_gc(p46, i45, descr=cdescr)
- p47 = new_array(i45, descr=arraydescr3) # Array(NODE)
- setfield_gc(p46, p47, descr=ddescr)
- i48 = int_lt(0, i43)
- guard_true(i48) []
- p49 = getarrayitem_gc(p42, 0, descr=arraydescr3) # NODE
- p50 = getfield_gc(p46, descr=ddescr) # Array(NODE)
- setarrayitem_gc(p50, 0, p49, descr=arraydescr3)
- i52 = int_lt(1, i43)
- guard_false(i52) []
- i53 = getfield_gc(p46, descr=cdescr)
- i55 = int_ne(i53, 1)
- guard_false(i55) []
- p56 = getfield_gc(p46, descr=ddescr) # Array(NODE)
- p58 = getarrayitem_gc(p56, 0, descr=arraydescr3) # NODE
- guard_nonnull(p38) []
- jump(p58)
- """
- self.find_nodes(ops, 'Virtual(node_vtable, valuedescr=Not)')
-
- # ------------------------------
- # Bridge tests
-
- def find_bridge(self, ops, inputspectext, outputspectext, boxkinds=None,
- mismatch=False):
- assert boxkinds is None or isinstance(boxkinds, dict)
- inputspecnodes = self.unpack_specnodes(inputspectext)
- outputspecnodes = self.unpack_specnodes(outputspectext)
- bridge = self.parse(ops, boxkinds=boxkinds)
- bridge_specialization_finder = BridgeSpecializationFinder(self.cpu)
- bridge_specialization_finder.find_nodes_bridge(bridge, inputspecnodes)
- matches = bridge_specialization_finder.bridge_matches(outputspecnodes)
- if mismatch:
- assert not matches
- else:
- assert matches
-
- def test_bridge_simple(self):
- ops = """
- [i0]
- i1 = int_add(i0, 1)
- jump(i1)
- """
- self.find_bridge(ops, 'Not', 'Not')
- self.find_bridge(ops, 'Not', 'Virtual(node_vtable)', mismatch=True)
-
- def test_bridge_simple_known_class(self):
- ops = """
- [p0]
- setfield_gc(p0, 123, descr=valuedescr)
- jump(p0)
- """
- self.find_bridge(ops, 'Not', 'Not')
-
- def test_bridge_simple_constant(self):
- ops = """
- []
- jump(ConstPtr(myptr))
- """
- self.find_bridge(ops, '', 'Not')
- self.find_bridge(ops, '', 'Constant(myptr)')
- self.find_bridge(ops, '', 'Constant(myptr2)', mismatch=True)
-
- def test_bridge_simple_constant_mismatch(self):
- ops = """
- [p0]
- jump(p0)
- """
- self.find_bridge(ops, 'Not', 'Not')
- self.find_bridge(ops, 'Not', 'Constant(myptr)', mismatch=True)
-
- def test_bridge_simple_virtual_1(self):
- ops = """
- [i0]
- p0 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p0, i0, descr=valuedescr)
- jump(p0)
- """
- self.find_bridge(ops, 'Not', 'Not')
- self.find_bridge(ops, 'Not', 'Virtual(node_vtable, valuedescr=Not)')
- self.find_bridge(ops, 'Not',
- '''Virtual(node_vtable,
- valuedescr=Not,
- nextdescr=Not)''')
- #
- self.find_bridge(ops, 'Not', 'Virtual(node_vtable)',
- mismatch=True) # missing valuedescr
- self.find_bridge(ops, 'Not', 'Virtual(node_vtable, nextdescr=Not)',
- mismatch=True) # missing valuedescr
- self.find_bridge(ops, 'Not', 'Virtual(node_vtable2, valuedescr=Not)',
- mismatch=True) # bad class
-
- def test_bridge_simple_virtual_struct(self):
- ops = """
- [i0]
- p0 = new(descr=ssize)
- setfield_gc(p0, i0, descr=adescr)
- jump(p0)
- """
- self.find_bridge(ops, 'Not', 'Not')
- self.find_bridge(ops, 'Not', 'VStruct(ssize, adescr=Not)')
-
- def test_bridge_simple_virtual_struct_non_unique(self):
- ops = """
- [i0]
- p0 = new(descr=ssize)
- setfield_gc(p0, i0, descr=adescr)
- jump(p0, p0)
- """
- self.find_bridge(ops, 'Not', 'Not, Not')
- self.find_bridge(ops, 'Not', 'VStruct(ssize), VStruct(ssize)',
- mismatch=True)
-
-
- def test_bridge_simple_virtual_2(self):
- ops = """
- [p0]
- setfield_gc(p0, 123, descr=valuedescr)
- jump(p0)
- """
- self.find_bridge(ops, 'Virtual(node_vtable)', 'Not')
- self.find_bridge(ops, 'Virtual(node_vtable)',
- 'Virtual(node_vtable, valuedescr=Not)')
- self.find_bridge(ops, 'Virtual(node_vtable, valuedescr=Not)',
- 'Virtual(node_vtable, valuedescr=Not)')
- self.find_bridge(ops, 'Virtual(node_vtable, valuedescr=Not)',
- '''Virtual(node_vtable,
- valuedescr=Not,
- nextdescr=Not)''')
- self.find_bridge(ops, '''Virtual(node_vtable,
- valuedescr=Not,
- nextdescr=Not)''',
- '''Virtual(node_vtable,
- valuedescr=Not,
- nextdescr=Not)''')
- #
- self.find_bridge(ops, 'Virtual(node_vtable)', 'Virtual(node_vtable)',
- mismatch=True) # because of missing valuedescr
- self.find_bridge(ops, 'Virtual(node_vtable)',
- 'Virtual(node_vtable2, valuedescr=Not)',
- mismatch=True) # bad class
-
- def test_bridge_virtual_mismatch_1(self):
- ops = """
- [i0]
- p0 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p0, i0, descr=valuedescr)
- jump(p0, p0)
- """
- self.find_bridge(ops, 'Not', 'Not, Not')
- #
- self.find_bridge(ops, 'Not',
- '''Virtual(node_vtable, valuedescr=Not),
- Virtual(node_vtable, valuedescr=Not)''',
- mismatch=True) # duplicate p0
-
- def test_bridge_guard_class(self):
- ops = """
- [p1]
- p2 = getfield_gc(p1, descr=nextdescr)
- guard_class(p2, ConstClass(node_vtable)) []
- jump(p2)
- """
- self.find_bridge(ops, 'Not', 'Not')
- self.find_bridge(ops, 'Virtual(node_vtable2, nextdescr=Not)', 'Not')
- self.find_bridge(ops,
- '''Virtual(node_vtable,
- nextdescr=Virtual(node_vtable,
- nextdescr=Not))''',
- '''Virtual(node_vtable,
- nextdescr=Not)''')
- #
- self.find_bridge(ops, 'Not', 'Virtual(node_vtable)',
- mismatch=True)
-
- def test_bridge_unused(self):
- ops = """
- []
- p1 = new_with_vtable(ConstClass(node_vtable))
- p2 = new_with_vtable(ConstClass(node_vtable))
- p3 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, p2, descr=nextdescr)
- setfield_gc(p2, p3, descr=nextdescr)
- jump(p1)
- """
- self.find_bridge(ops, '',
- '''Not''')
- self.find_bridge(ops, '',
- '''Virtual(node_vtable,
- nextdescr=Not)''')
- self.find_bridge(ops, '',
- '''Virtual(node_vtable,
- nextdescr=Virtual(node_vtable,
- nextdescr=Not))''')
- self.find_bridge(ops, '',
- '''Virtual(node_vtable,
- nextdescr=Virtual(node_vtable,
- nextdescr=Virtual(node_vtable)))''')
- self.find_bridge(ops, '',
- '''Virtual(node_vtable,
- nextdescr=Virtual(node_vtable,
- nextdescr=Virtual(node_vtable,
- nextdescr=Not)))''')
-
- def test_bridge_to_finish(self):
- ops = """
- [i1]
- i2 = int_add(i1, 5)
- finish(i2)
- """
- self.find_bridge(ops, 'Not', 'Not')
-
- def test_bridge_virtual_to_finish(self):
- ops = """
- [i1]
- p1 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, i1, descr=valuedescr)
- finish(p1)
- """
- self.find_bridge(ops, 'Not', 'Not')
- self.find_bridge(ops, 'Not',
- 'Virtual(node_vtable, valuedescr=Not)',
- mismatch=True)
-
- def test_bridge_array_virtual_1(self):
- ops = """
- [i1]
- p1 = new_array(3, descr=arraydescr)
- setarrayitem_gc(p1, 0, i1, descr=arraydescr)
- jump(p1)
- """
- self.find_bridge(ops, 'Not', 'Not')
- self.find_bridge(ops, 'Not', 'VArray(arraydescr, Not, Not, Not)')
-
- def test_bridge_array_virtual_size_mismatch(self):
- ops = """
- [i1]
- p1 = new_array(5, descr=arraydescr)
- setarrayitem_gc(p1, 0, i1, descr=arraydescr)
- jump(p1)
- """
- self.find_bridge(ops, 'Not', 'Not')
- self.find_bridge(ops, 'Not', 'VArray(arraydescr, Not, Not, Not)',
- mismatch=True)
-
- def test_bridge_array_virtual_2(self):
- ops = """
- [i1]
- p1 = new_array(3, descr=arraydescr)
- setarrayitem_gc(p1, 0, i1, descr=arraydescr)
- escape(p1)
- jump(p1)
- """
- self.find_bridge(ops, 'Not', 'Not')
- self.find_bridge(ops, 'Not', 'VArray(arraydescr, Not, Not, Not)',
- mismatch=True)
-
- def test_bridge_nested_structs(self):
- ops = """
- []
- p1 = new_with_vtable(ConstClass(node_vtable))
- p2 = new_with_vtable(ConstClass(node_vtable))
- setfield_gc(p1, p2, descr=nextdescr)
- jump(p1)
- """
- self.find_bridge(ops, '', 'Not')
- self.find_bridge(ops, '', 'Virtual(node_vtable, nextdescr=Not)')
- self.find_bridge(ops, '',
- 'Virtual(node_vtable, nextdescr=Virtual(node_vtable))')
- self.find_bridge(ops, '',
- 'Virtual(node_vtable, nextdescr=Virtual(node_vtable2))',
- mismatch=True)
-
-
-class TestLLtype(BaseTestOptimizeFindNode, LLtypeMixin):
- pass
-
-##class TestOOtype(BaseTestOptimizeFindNode, OOtypeMixin):
-## def test_find_nodes_instanceof(self):
-## ops = """
-## [i0]
-## p0 = new_with_vtable(ConstClass(node_vtable))
-## i1 = instanceof(p0, descr=nodesize)
-## jump(i1)
-## """
-## boxes, getnode = self.find_nodes(ops, 'Not')
-## assert not getnode(boxes.p0).escaped
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_resume.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_resume.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_resume.py Sat Oct 30 16:58:59 2010
@@ -5,7 +5,7 @@
from pypy.jit.metainterp.resume import *
from pypy.jit.metainterp.history import BoxInt, BoxPtr, ConstInt
from pypy.jit.metainterp.history import ConstPtr, ConstFloat
-from pypy.jit.metainterp.test.test_optimizefindnode import LLtypeMixin
+from pypy.jit.metainterp.test.test_optimizeutil import LLtypeMixin
from pypy.jit.metainterp import executor
from pypy.jit.codewriter import heaptracker
Modified: pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_virtualizable.py
==============================================================================
--- pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_virtualizable.py (original)
+++ pypy/branch/jit-unroll-loops/pypy/jit/metainterp/test/test_virtualizable.py Sat Oct 30 16:58:59 2010
@@ -11,7 +11,7 @@
from pypy.rpython.rclass import FieldListAccessor
from pypy.jit.metainterp.warmspot import get_stats, get_translator
from pypy.jit.metainterp import history
-from pypy.jit.metainterp.test.test_optimizefindnode import LLtypeMixin
+from pypy.jit.metainterp.test.test_optimizeutil import LLtypeMixin
def promote_virtualizable(*args):
pass
More information about the Pypy-commit
mailing list