[pypy-commit] pypy vecopt: generalized extend

[plan_rich]

Author: Richard Plangger <rich at pasra.at>
Branch: vecopt
Changeset: r77688:d89d708eeea2
Date: 2015-05-29 14:36 +0200
http://bitbucket.org/pypy/pypy/changeset/d89d708eeea2/

Log:	generalized extend dont overwrite resume at loop header descr in
	unrolling (this will lead to stronger dependencies)

diff --git a/rpython/jit/metainterp/optimizeopt/test/test_vectorize.py b/rpython/jit/metainterp/optimizeopt/test/test_vectorize.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_vectorize.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_vectorize.py
@@ -1300,18 +1300,19 @@
 
     def test_abc(self):
         trace ="""
-        [p0, p1, p5, i6, i7, p3, p8, i9, i10, i11, i12, i13, i14, p15]
-        guard_early_exit() [p3, p1, p0, i9, p5, p8, i6, i7, i10]
-        f16 = raw_load(i11, i7, descr=floatarraydescr)
-        guard_not_invalidated() [p3, p1, p0, f16, i9, p5, p8, i6, i7, i10]
-        raw_store(i12, i10, f16, descr=floatarraydescr)
-        i18 = int_add(i9, 1)
-        i19 = int_add(i10, i13)
-        i21 = int_add(i7, 8)
-        i22 = int_ge(i18, i14)
-        guard_false(i22) [p3, p1, p0, i21, i19, i18, None, p5, p8, i6, None, None]
-        i24 = arraylen_gc(p15, descr=floatarraydescr)
-        jump(p0, p1, p5, i6, i21, p3, p8, i18, i19, i11, i12, i13, i14, p15)
+        [p0, p9, i10, p2, i11, p12, i13, p7, i14, f15, p5, p6, i16, f17, i18, i19]
+        guard_early_exit() [p7, p6, p5, p2, p0, i10, i14, i11, p12, i13, f15, p9]
+        i20 = raw_load(i16, i11, descr=floatarraydescr)
+        guard_not_invalidated() [p7, p6, p5, p2, p0, i20, i10, i14, i11, p12, i13, None, p9]
+        f22 = cast_int_to_float(i20)
+        i24 = int_add(i11, 8)
+        f25 = float_add(f22, f17)
+        raw_store(i18, i14, f25, descr=floatarraydescr)
+        i27 = int_add(i13, 1)
+        i29 = int_add(i14, 8)
+        i30 = int_ge(i27, i19)
+        guard_false(i30) [p7, p6, p5, p2, p0, i24, i27, i29, f22, i10, None, None, p12, None, None, p9]
+        jump(p0, p9, i10, p2, i24, p12, i27, p7, i29, f22, p5, p6, i16, f17, i18, i19)
         """
         opt = self.vectorize(self.parse_loop(trace))
         self.debug_print_operations(opt.loop)
diff --git a/rpython/jit/metainterp/optimizeopt/vectorize.py b/rpython/jit/metainterp/optimizeopt/vectorize.py
--- a/rpython/jit/metainterp/optimizeopt/vectorize.py
+++ b/rpython/jit/metainterp/optimizeopt/vectorize.py
@@ -201,10 +201,12 @@
                 if copied_op.is_guard():
                     assert isinstance(copied_op, GuardResOp)
                     target_guard = copied_op
-                    descr = invent_fail_descr_for_op(copied_op.getopnum(), self)
-                    olddescr = copied_op.getdescr()
-                    descr.copy_all_attributes_from(olddescr)
-                    copied_op.setdescr(descr)
+                    if not isinstance(target_guard.getdescr(), ResumeAtLoopHeaderDescr):
+                        # do not overwrite resume at loop header
+                        descr = invent_fail_descr_for_op(copied_op.getopnum(), self)
+                        olddescr = copied_op.getdescr()
+                        descr.copy_all_attributes_from(olddescr)
+                        copied_op.setdescr(descr)
 
                     if oi < ee_pos:
                         # do not clone the arguments, it is already an early exit
@@ -871,6 +873,15 @@
             vbox = self.expand_box_to_vector_box(vbox, ops, arg, argidx)
             box_pos = 0
 
+        enforced_type = self.ptype
+        # convert type f -> i, i -> f
+        # if enforced_type.gettype() != vbox.gettype():
+        #     raise NotImplementedError("cannot yet convert between types")
+
+        # convert size i64 -> i32, i32 -> i64, ...
+        if enforced_type.getsize() != vbox.getsize():
+            vbox = self.extend(vbox, self.ptype)
+
         # use the input as an indicator for the pack type
         arg_ptype = PackType.of(vbox)
         packable = self.sched_data.vec_reg_size // arg_ptype.getsize()
@@ -884,24 +895,30 @@
         elif packed > packable:
             # the argument has more items than the operation is able to process!
             vbox = self.unpack(vbox, off, packable, arg_ptype)
-            vbox = self.extend(vbox, arg_ptype)
-            # continue to handle the rest of the vbox
         #
-        # The instruction takes less items than the vector has.
-        # Unpack if not at off 0
         if off != 0 and box_pos != 0:
+            # The original box is at a position != 0 but it
+            # is required to be at position 0. Unpack it!
             vbox = self.unpack(vbox, off, len(ops), arg_ptype)
         #
         return vbox
 
-    def extend(self, vbox, arg_ptype):
+    def extend(self, vbox, newtype):
         if vbox.item_count * vbox.item_size == self.sched_data.vec_reg_size:
             return vbox
-        size = arg_ptype.getsize()
-        assert (vbox.item_count * size) == self.sched_data.vec_reg_size
-        opnum = rop.VEC_INT_SIGNEXT
-        vbox_cloned = arg_ptype.new_vector_box(vbox.item_count)
-        op = ResOperation(opnum, [vbox, ConstInt(size), ConstInt(vbox.item_count)], vbox_cloned)
+        assert vbox.gettype() == newtype.gettype()
+        assert (vbox.item_count * newtype.getsize()) == \
+               self.sched_data.vec_reg_size
+        if vbox.gettype() == INT:
+            return self.extend_int(vbox, newtype)
+        else:
+            raise NotImplementedError("cannot yet extend float")
+
+    def extend_int(self, vbox, newtype):
+        vbox_cloned = newtype.new_vector_box(vbox.item_count)
+        op = ResOperation(rop.VEC_INT_SIGNEXT, 
+                          [vbox, ConstInt(newtype.getsize())],
+                          vbox_cloned)
         self.preamble_ops.append(op)
         return vbox_cloned