[pypy-commit] pypy recent-pure-ops: a bit random progress

[fijal]

Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: recent-pure-ops
Changeset: r76220:0b3667fb138c
Date: 2015-02-28 16:08 +0200
http://bitbucket.org/pypy/pypy/changeset/0b3667fb138c/

Log:	a bit random progress

diff --git a/rpython/jit/metainterp/optimizeopt/optimizer.py b/rpython/jit/metainterp/optimizeopt/optimizer.py
--- a/rpython/jit/metainterp/optimizeopt/optimizer.py
+++ b/rpython/jit/metainterp/optimizeopt/optimizer.py
@@ -452,6 +452,9 @@
     def getvalue(self, box):
         return self.optimizer.getvalue(box)
 
+    def get_box_replacement(self, box):
+        return self.optimizer.get_box_replacement(box)
+
     def make_constant(self, box, constbox):
         return self.optimizer.make_constant(box, constbox)
 
@@ -845,16 +848,6 @@
                 descr.make_a_counter_per_value(op)
         return op
 
-    def make_args_key(self, op):
-        n = op.numargs()
-        args = [None] * (n + 2)
-        for i in range(n):
-            arg = self.get_box_replacement(op.getarg(i))
-            args[i] = arg
-        args[n] = ConstInt(op.getopnum())
-        args[n + 1] = op.getdescr()
-        return args
-
     def optimize_default(self, op):
         self.emit_operation(op)
 
diff --git a/rpython/jit/metainterp/optimizeopt/pure.py b/rpython/jit/metainterp/optimizeopt/pure.py
--- a/rpython/jit/metainterp/optimizeopt/pure.py
+++ b/rpython/jit/metainterp/optimizeopt/pure.py
@@ -15,31 +15,34 @@
         self.next_index = (next_index + 1) % self.REMEMBER_LIMIT
         self.lst[next_index] = op
 
-    def lookup1(self, box0):
+    def lookup1(self, box0, descr):
         for i in range(self.REMEMBER_LIMIT):
             op = self.lst[i]
             if op is None:
                 break
-            if op.getarg(0).same_box(box0):
+            if op.getarg(0).same_box(box0) and op.getdescr() is descr:
                 return op
         return None
 
-    def lookup2(self, box0, box1):
+    def lookup2(self, box0, box1, descr):
         for i in range(self.REMEMBER_LIMIT):
             op = self.lst[i]
             if op is None:
                 break
-            if op.getarg(0).same_box(box0) and op.getarg(1).same_box(box1):
+            if (op.getarg(0).same_box(box0) and op.getarg(1).same_box(box1)
+                and op.getdescr() is descr):
                 return op
         return None
 
     def lookup(self, optimizer, op):
         numargs = op.numargs()
         if numargs == 1:
-            return self.lookup1(optimizer.get_box_replacement(op.getarg(0)))
+            return self.lookup1(optimizer.get_box_replacement(op.getarg(0)),
+                                op.getdescr())
         elif numargs == 2:
             return self.lookup2(optimizer.get_box_replacement(op.getarg(0)),
-                                optimizer.get_box_replacement(op.getarg(1)))
+                                optimizer.get_box_replacement(op.getarg(1)),
+                                op.getdescr())
         else:
             assert False
 
@@ -67,7 +70,6 @@
         else:
             nextop = None
 
-        args = None
         if canfold:
             for i in range(op.numargs()):
                 if self.get_constant_box(op.getarg(i)) is None:
@@ -150,17 +152,18 @@
 
     def pure(self, opnum, args, result):
         op = ResOperation(opnum, args, result)
-        key = self.optimizer.make_args_key(op)
-        if key not in self.pure_operations:
-            self.pure_operations[key] = self.getvalue(result)
+        recentops = self.getrecentops(opnum)
+        recentops.add(op)
 
     def has_pure_result(self, opnum, args, descr):
+        return False
         op = ResOperation(opnum, args, None, descr)
         key = self.optimizer.make_args_key(op)
         return self.pure_operations.get(key, None) is not None
 
-    def get_pure_result(self, key):
-        return self.pure_operations.get(key, None)
+    def get_pure_result(self, op):
+        recentops = self.getrecentops(op.getopnum())
+        return recentops.lookup(self.optimizer, op)
 
     def produce_potential_short_preamble_ops(self, sb):
         ops = sb.optimizer._newoperations
diff --git a/rpython/jit/metainterp/optimizeopt/rewrite.py b/rpython/jit/metainterp/optimizeopt/rewrite.py
--- a/rpython/jit/metainterp/optimizeopt/rewrite.py
+++ b/rpython/jit/metainterp/optimizeopt/rewrite.py
@@ -26,15 +26,15 @@
 
     def propagate_forward(self, op):
         if op.boolinverse != -1 or op.boolreflex != -1:
-            args = self.optimizer.make_args_key(op)
-            if self.find_rewritable_bool(op, args):
+            if self.find_rewritable_bool(op):
                 return
 
         dispatch_opt(self, op)
 
     def try_boolinvers(self, op, targs):
-        value = self.get_pure_result(targs)
-        if value is not None:
+        op = self.get_pure_result(targs)
+        if op is not None:
+            value = self.getvalue(op.result)
             if value.is_constant():
                 if value.box.same_constant(CONST_1):
                     self.make_constant(op.result, CONST_0)
@@ -46,30 +46,30 @@
         return False
 
 
-    def find_rewritable_bool(self, op, args):
+    def find_rewritable_bool(self, op):
         oldopnum = op.boolinverse
+        arg0 = op.getarg(0)
+        arg1 = op.getarg(1)
         if oldopnum != -1:
-            targs = self.optimizer.make_args_key(ResOperation(oldopnum, [args[0], args[1]],
-                                                              None))
-            if self.try_boolinvers(op, targs):
+            top = ResOperation(oldopnum, [arg0, arg1], None)
+            if self.try_boolinvers(op, top):
                 return True
 
         oldopnum = op.boolreflex # FIXME: add INT_ADD, INT_MUL
         if oldopnum != -1:
-            targs = self.optimizer.make_args_key(ResOperation(oldopnum, [args[1], args[0]],
-                                                              None))
-            value = self.get_pure_result(targs)
-            if value is not None:
-                self.optimizer.make_equal_to(op.result, value, True)
+            top = ResOperation(oldopnum, [arg0, arg1], None)
+            oldop = self.get_pure_result(top)
+            if oldop is not None:
+                self.optimizer.make_equal_to(op.result, self.getvalue(oldop),
+                                             True)
                 return True
 
         if op.boolreflex == -1:
             return False
         oldopnum = opclasses[op.boolreflex].boolinverse
         if oldopnum != -1:
-            targs = self.optimizer.make_args_key(
-                ResOperation(oldopnum, [args[1], args[0]], None))
-            if self.try_boolinvers(op, targs):
+            top = ResOperation(oldopnum, [arg1, arg0], None)
+            if self.try_boolinvers(op, top):
                 return True
 
         return False