[pypy-svn] r65580 - in pypy/branch/pyjitpl5-experiments/pypy/jit/metainterp: . test

[antocuni at codespeak.net]

Author: antocuni
Date: Thu Jun  4 18:09:10 2009
New Revision: 65580

Modified:
   pypy/branch/pyjitpl5-experiments/pypy/jit/metainterp/optimize3.py
   pypy/branch/pyjitpl5-experiments/pypy/jit/metainterp/test/test_optimize3.py
Log:
constant fold away guards that always passes. Also, be sure not to call fixop
(and hence new_arguments) more than once for each op



Modified: pypy/branch/pyjitpl5-experiments/pypy/jit/metainterp/optimize3.py
==============================================================================
--- pypy/branch/pyjitpl5-experiments/pypy/jit/metainterp/optimize3.py	(original)
+++ pypy/branch/pyjitpl5-experiments/pypy/jit/metainterp/optimize3.py	Thu Jun  4 18:09:10 2009
@@ -21,6 +21,7 @@
 class Specializer(object):
     loop = None
     nodes = None
+    fixedops = None
 
     def __init__(self, optlist):
         self.optlist = optlist
@@ -89,9 +90,17 @@
 
     def fixop(self, op):
         if op is None:
-            return
+            return None
+        if op in self.fixedops:
+            return op
         if op.is_guard():
-            return self.fixguard(op)
+            newop = self._fixguard(op)
+        else:
+            newop = self._fixop_default(op)
+        self.fixedops[newop] = None
+        return newop
+
+    def _fixop_default(self, op):
         op = op.clone()
         op.args = self.new_arguments(op)
         if op.is_always_pure():
@@ -107,7 +116,14 @@
                 return
         return op
 
-    def fixguard(self, op):
+    def _fixguard(self, op):
+        if op.is_foldable_guard():
+            for arg in op.args:
+                if not self.getnode(arg).const:
+                    break
+            else:
+                return None
+        op.args = self.new_arguments(op)
         assert len(op.suboperations) == 1
         op_fail = op.suboperations[0]
         op_fail.args = self.new_arguments(op_fail)
@@ -119,6 +135,7 @@
     def optimize_loop(self, loop):
         self.nodes = {}
         self.field_caches = {}
+        self.fixedops = {}
         self.loop = loop
         self.find_nodes()
         self.optimize_operations()
@@ -165,7 +182,7 @@
         assert isinstance(op.args[1], Const)
         if instnode.const:
             return
-        #op = spec.fixguard(op) # ??
+        op = spec.fixop(op)
         instnode.const = True
         instnode.source = op.args[0].constbox()
         return op

Modified: pypy/branch/pyjitpl5-experiments/pypy/jit/metainterp/test/test_optimize3.py
==============================================================================
--- pypy/branch/pyjitpl5-experiments/pypy/jit/metainterp/test/test_optimize3.py	(original)
+++ pypy/branch/pyjitpl5-experiments/pypy/jit/metainterp/test/test_optimize3.py	Thu Jun  4 18:09:10 2009
@@ -91,10 +91,11 @@
             optlist = []
         optimize_loop(None, [], loop, self.cpu,
                       spec=Specializer(optlist))
-        return loop.operations
+        return loop
 
     def assert_equal(self, optimized, expected):
-        equaloplists(optimized, self.parse(expected).operations)
+        equaloplists(optimized.operations,
+                     self.parse(expected).operations)
 
 
     def test_constfold(self):
@@ -110,6 +111,18 @@
             expected = "[]"
             self.assert_equal(self.optimize(ops), expected)
 
+    def test_constfold_guard(self):
+        ops = """
+        []
+        i0 = int_add(0, 0)
+        guard_value(i0, 0)
+          fail(i0)
+        """
+        expected = """
+        []
+        """
+        loop = self.optimize(ops, [])
+        self.assert_equal(loop, expected)
 
     def test_remove_guard_class(self):
         ops = """
@@ -143,7 +156,11 @@
         guard_value(i0, 0)
             fail()
         """
-        loop = self.optimize(ops, [OptimizeGuards()])
+        loop = self.parse(ops)
+        # cheat
+        loop.operations[1].result.value = 1
+        loop.operations[3].result.value = 3
+        loop = self.optimize(loop, [OptimizeGuards()])
         self.assert_equal(loop, expected)