[pypy-commit] pypy unrecursive-opt: Move virtualize callbacks to postprocess pass.

jerith noreply at buildbot.pypy.org
Sun Oct 4 17:31:11 CEST 2015


Author: Jeremy Thurgood <firxen at gmail.com>
Branch: unrecursive-opt
Changeset: r79978:bffdacba8eaa
Date: 2015-10-04 17:22 +0200
http://bitbucket.org/pypy/pypy/changeset/bffdacba8eaa/

Log:	Move virtualize callbacks to postprocess pass.

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
@@ -272,7 +272,7 @@
 
     def set_optimizations(self, optimizations):
         if optimizations:
-            self.first_optimization = optimizations[2]
+            self.first_optimization = optimizations[3]
             for i in range(1, len(optimizations)):
                 optimizations[i - 1].next_optimization = optimizations[i]
             optimizations[-1].next_optimization = self
@@ -539,13 +539,13 @@
 
     def send_extra_operation(self, op):
         oldop = op
-        for optimization in self.optimizations[:2]:
+        for optimization in self.optimizations[:3]:
             op = optimization.propagate_forward(op)
             if op is None:
                 return
             optimization.last_emitted_operation = op
         self.first_optimization.propagate_forward(op)
-        for optimization in reversed(self.optimizations[:2]):
+        for optimization in reversed(self.optimizations[:3]):
             optimization.propagate_postprocess(op, oldop)
 
     def propagate_forward(self, op):
diff --git a/rpython/jit/metainterp/optimizeopt/virtualize.py b/rpython/jit/metainterp/optimizeopt/virtualize.py
--- a/rpython/jit/metainterp/optimizeopt/virtualize.py
+++ b/rpython/jit/metainterp/optimizeopt/virtualize.py
@@ -13,6 +13,10 @@
     "Virtualize objects until they escape."
 
     _last_guard_not_forced_2 = None
+    _finish_guard_op = None
+
+    def opt_default(self, op):
+        return op
 
     def make_virtual(self, known_class, source_op, descr):
         opinfo = info.InstancePtrInfo(descr, known_class, is_virtual=True)
@@ -55,29 +59,27 @@
     def optimize_GUARD_NO_EXCEPTION(self, op):
         if self.last_emitted_operation is REMOVED:
             return
-        self.emit_operation(op)
+        return op
 
     def optimize_GUARD_NOT_FORCED(self, op):
         if self.last_emitted_operation is REMOVED:
             return
-        self.emit_operation(op)
+        return op
 
     def optimize_GUARD_NOT_FORCED_2(self, op):
         self._last_guard_not_forced_2 = op
 
     def optimize_FINISH(self, op):
-        if self._last_guard_not_forced_2 is not None:
-            guard_op = self._last_guard_not_forced_2
-            self.emit_operation(op)
-            self.optimize_FINISH_callback(op, guard_op)
-        else:
-            self.emit_operation(op)
+        self._finish_guard_op = self._last_guard_not_forced_2
+        return op
 
-    def optimize_FINISH_callback(self, op, guard_op):
-        guard_op = self.optimizer.store_final_boxes_in_guard(guard_op, [])
-        i = len(self.optimizer._newoperations) - 1
-        assert i >= 0
-        self.optimizer._newoperations.insert(i, guard_op)
+    def postprocess_FINISH(self, op, oldop):
+        guard_op = self._finish_guard_op
+        if guard_op is not None:
+            guard_op = self.optimizer.store_final_boxes_in_guard(guard_op, [])
+            i = len(self.optimizer._newoperations) - 1
+            assert i >= 0
+            self.optimizer._newoperations.insert(i, guard_op)
 
     def optimize_CALL_MAY_FORCE_I(self, op):
         effectinfo = op.getdescr().get_extra_info()
@@ -85,7 +87,7 @@
         if oopspecindex == EffectInfo.OS_JIT_FORCE_VIRTUAL:
             if self._optimize_JIT_FORCE_VIRTUAL(op):
                 return
-        self.emit_operation(op)
+        return op
     optimize_CALL_MAY_FORCE_R = optimize_CALL_MAY_FORCE_I
     optimize_CALL_MAY_FORCE_F = optimize_CALL_MAY_FORCE_I
     optimize_CALL_MAY_FORCE_N = optimize_CALL_MAY_FORCE_I
@@ -97,13 +99,15 @@
             opinfo = self.getptrinfo(op.getarg(2))
             if opinfo and opinfo.is_virtual():
                 return
-        self.emit_operation(op)
+        return op
 
     def optimize_VIRTUAL_REF(self, op):
         # get some constants
         vrefinfo = self.optimizer.metainterp_sd.virtualref_info
         c_cls = vrefinfo.jit_virtual_ref_const_class
         vref_descr = vrefinfo.descr
+        descr_virtual_token = vrefinfo.descr_virtual_token
+        descr_forced = vrefinfo.descr_forced
         #
         # Replace the VIRTUAL_REF operation with a virtual structure of type
         # 'jit_virtual_ref'.  The jit_virtual_ref structure may be forced soon,
@@ -113,16 +117,10 @@
         op.set_forwarded(newop)
         newop.set_forwarded(vrefvalue)
         token = ResOperation(rop.FORCE_TOKEN, [])
-        self.emit_operation(token)
-        self.optimize_VIRTUAL_REF_callback(op, vrefvalue, newop, token)
-
-    def optimize_VIRTUAL_REF_callback(self, op, vrefvalue, newop, token):
-        vrefinfo = self.optimizer.metainterp_sd.virtualref_info
-        descr_virtual_token = vrefinfo.descr_virtual_token
-        descr_forced = vrefinfo.descr_forced
         vrefvalue.setfield(descr_virtual_token, newop, token)
         vrefvalue.setfield(descr_forced, newop,
                            self.optimizer.cpu.ts.CONST_NULLREF)
+        return token
 
     def optimize_VIRTUAL_REF_FINISH(self, op):
         # This operation is used in two cases.  In normal cases, it
@@ -185,7 +183,7 @@
             self.make_equal_to(op, fieldop)
         else:
             self.make_nonnull(op.getarg(0))
-            self.emit_operation(op)
+            return op
     optimize_GETFIELD_GC_R = optimize_GETFIELD_GC_I
     optimize_GETFIELD_GC_F = optimize_GETFIELD_GC_I
 
@@ -203,7 +201,7 @@
                             self.get_box_replacement(op.getarg(1)))
         else:
             self.make_nonnull(struct)
-            self.emit_operation(op)
+            return op
 
     def optimize_NEW_WITH_VTABLE(self, op):
         known_class = ConstInt(op.getdescr().get_vtable())
@@ -217,36 +215,35 @@
         if sizebox is not None:
             self.make_varray(op.getdescr(), sizebox.getint(), op)
         else:
-            self.emit_operation(op)
+            return op
 
     def optimize_NEW_ARRAY_CLEAR(self, op):
         sizebox = self.get_constant_box(op.getarg(0))
         if sizebox is not None:
             self.make_varray(op.getdescr(), sizebox.getint(), op, clear=True)
         else:
-            self.emit_operation(op)        
+            return op
 
     def optimize_CALL_N(self, op):
         effectinfo = op.getdescr().get_extra_info()
         if effectinfo.oopspecindex == EffectInfo.OS_RAW_MALLOC_VARSIZE_CHAR:
-            self.do_RAW_MALLOC_VARSIZE_CHAR(op)
+            return self.do_RAW_MALLOC_VARSIZE_CHAR(op)
         elif effectinfo.oopspecindex == EffectInfo.OS_RAW_FREE:
-            self.do_RAW_FREE(op)
+            return self.do_RAW_FREE(op)
         elif effectinfo.oopspecindex == EffectInfo.OS_JIT_FORCE_VIRTUALIZABLE:
             # we might end up having CALL here instead of COND_CALL
             info = self.getptrinfo(op.getarg(1))
             if info and info.is_virtual():
                 return
         else:
-            self.emit_operation(op)
+            return op
     optimize_CALL_R = optimize_CALL_N
     optimize_CALL_I = optimize_CALL_N
 
     def do_RAW_MALLOC_VARSIZE_CHAR(self, op):
         sizebox = self.get_constant_box(op.getarg(1))
         if sizebox is None:
-            self.emit_operation(op)
-            return
+            return op
         self.make_virtual_raw_memory(sizebox.getint(), op)
         self.last_emitted_operation = REMOVED
 
@@ -254,7 +251,7 @@
         opinfo = self.getrawptrinfo(op.getarg(1))
         if opinfo and opinfo.is_virtual():
             return
-        self.emit_operation(op)
+        return op
 
     def optimize_INT_ADD(self, op):
         opinfo = self.getrawptrinfo(op.getarg(0), create=False)
@@ -267,7 +264,7 @@
                 isinstance(opinfo, info.RawSlicePtrInfo)):
                 self.make_virtual_raw_slice(offset, opinfo, op)
                 return
-        self.emit_operation(op)
+        return op
 
     def optimize_ARRAYLEN_GC(self, op):
         opinfo = self.getptrinfo(op.getarg(0))
@@ -275,7 +272,7 @@
             self.make_constant_int(op, opinfo.getlength())
         else:
             self.make_nonnull(op.getarg(0))
-            self.emit_operation(op)
+            return op
 
     def optimize_GETARRAYITEM_GC_I(self, op):
         opinfo = self.getptrinfo(op.getarg(0))
@@ -289,7 +286,7 @@
                 self.make_equal_to(op, item)
                 return
         self.make_nonnull(op.getarg(0))
-        self.emit_operation(op)
+        return op
     optimize_GETARRAYITEM_GC_R = optimize_GETARRAYITEM_GC_I
     optimize_GETARRAYITEM_GC_F = optimize_GETARRAYITEM_GC_I
 
@@ -309,7 +306,7 @@
                                self.get_box_replacement(op.getarg(2)))
                 return
         self.make_nonnull(op.getarg(0))
-        self.emit_operation(op)
+        return op
 
     def _unpack_arrayitem_raw_op(self, op, indexbox):
         index = indexbox.getint()
@@ -334,7 +331,7 @@
                     self.make_equal_to(op, itemvalue)
                     return
         self.make_nonnull(op.getarg(0))
-        self.emit_operation(op)
+        return op
     optimize_GETARRAYITEM_RAW_F = optimize_GETARRAYITEM_RAW_I
 
     def optimize_SETARRAYITEM_RAW(self, op):
@@ -350,7 +347,7 @@
                 except InvalidRawOperation:
                     pass
         self.make_nonnull(op.getarg(0))
-        self.emit_operation(op)
+        return op
 
     def _unpack_raw_load_store_op(self, op, offsetbox):
         offset = offsetbox.getint()
@@ -372,7 +369,7 @@
                 else:
                     self.make_equal_to(op, itemop)
                     return
-        self.emit_operation(op)
+        return op
     optimize_RAW_LOAD_F = optimize_RAW_LOAD_I
 
     def optimize_RAW_STORE(self, op):
@@ -386,7 +383,7 @@
                     return
                 except InvalidRawOperation:
                     pass
-        self.emit_operation(op)
+        return op
 
     def optimize_GETINTERIORFIELD_GC_I(self, op):
         opinfo = self.getptrinfo(op.getarg(0))
@@ -402,7 +399,7 @@
                 self.make_equal_to(op, fld)
                 return
         self.make_nonnull(op.getarg(0))
-        self.emit_operation(op)
+        return op
     optimize_GETINTERIORFIELD_GC_R = optimize_GETINTERIORFIELD_GC_I
     optimize_GETINTERIORFIELD_GC_F = optimize_GETINTERIORFIELD_GC_I
 
@@ -416,10 +413,12 @@
                                        self.get_box_replacement(op.getarg(2)))
                 return
         self.make_nonnull(op.getarg(0))
-        self.emit_operation(op)
+        return op
 
 
 dispatch_opt = make_dispatcher_method(OptVirtualize, 'optimize_',
-        default=OptVirtualize.emit_operation)
+        default=OptVirtualize.opt_default)
 
 OptVirtualize.propagate_forward = dispatch_opt
+dispatch_postprocess = make_dispatcher_method(OptVirtualize, 'postprocess_')
+OptVirtualize.propagate_postprocess = dispatch_postprocess


More information about the pypy-commit mailing list