Vector peeling cost model 1/6

gcc/ChangeLog:

2017-05-30  Robin Dapp  <rdapp@linux.vnet.ibm.com>

	* tree-vect-data-refs.c (vect_compute_data_ref_alignment): Create
	DR_HAS_NEGATIVE_STEP.
	(vect_update_misalignment_for_peel): Define DR_MISALIGNMENT.
	(vect_enhance_data_refs_alignment): Use.
	(vect_duplicate_ssa_name_ptr_info): Use.
	* tree-vectorizer.h (dr_misalignment): Use.
	(known_alignment_for_access_p): Use.

From-SVN: r248675

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 49a8a6135478760c33344207104dc77009878f41..585129bdd5e974edebbf554344ca0bc147c71988 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,13 @@
+2017-05-30  Robin Dapp  <rdapp@linux.vnet.ibm.com>
+
+       * tree-vect-data-refs.c (vect_compute_data_ref_alignment): Create
+       DR_HAS_NEGATIVE_STEP.
+       (vect_update_misalignment_for_peel): Define DR_MISALIGNMENT.
+       (vect_enhance_data_refs_alignment): Use.
+       (vect_duplicate_ssa_name_ptr_info): Use.
+       * tree-vectorizer.h (dr_misalignment): Use.
+       (known_alignment_for_access_p): Use.
+
 2017-05-30  Jozef Lawrynowicz  <jozef.l@somniumtech.com>
 
        PR target/78838

diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c
index a1ef24ed1d51e98f00e9f6842c4d4526d39e31c0..c683fb1ecba6a2c7721db758d902f7da2b7581d5 100644 (file)
--- a/gcc/tree-vect-data-refs.c
+++ b/gcc/tree-vect-data-refs.c
@@ -717,7 +717,7 @@ vect_compute_data_ref_alignment (struct data_reference *dr)
     loop = LOOP_VINFO_LOOP (loop_vinfo);
 
   /* Initialize misalignment to unknown.  */
-  SET_DR_MISALIGNMENT (dr, -1);
+  SET_DR_MISALIGNMENT (dr, DR_MISALIGNMENT_UNKNOWN);
 
   if (tree_fits_shwi_p (DR_STEP (dr)))
     misalign = DR_INIT (dr);
@@ -957,8 +957,9 @@ vect_update_misalignment_for_peel (struct data_reference *dr,
     }
 
   if (dump_enabled_p ())
-    dump_printf_loc (MSG_NOTE, vect_location, "Setting misalignment to -1.\n");
-  SET_DR_MISALIGNMENT (dr, -1);
+    dump_printf_loc (MSG_NOTE, vect_location, "Setting misalignment " \
+                    "to unknown (-1).\n");
+  SET_DR_MISALIGNMENT (dr, DR_MISALIGNMENT_UNKNOWN);
 }
 
 
@@ -1526,32 +1527,31 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
         {
           if (known_alignment_for_access_p (dr))
             {
-              unsigned int npeel_tmp;
+              unsigned int npeel_tmp = 0;
              bool negative = tree_int_cst_compare (DR_STEP (dr),
                                                    size_zero_node) < 0;
 
-              /* Save info about DR in the hash table.  */
               vectype = STMT_VINFO_VECTYPE (stmt_info);
               nelements = TYPE_VECTOR_SUBPARTS (vectype);
               mis = DR_MISALIGNMENT (dr) / GET_MODE_SIZE (TYPE_MODE (
                                                 TREE_TYPE (DR_REF (dr))));
-              npeel_tmp = (negative
-                          ? (mis - nelements) : (nelements - mis))
-                 & (nelements - 1);
+             if (DR_MISALIGNMENT (dr) != 0)
+               npeel_tmp = (negative ? (mis - nelements)
+                            : (nelements - mis)) & (nelements - 1);
 
               /* For multiple types, it is possible that the bigger type access
                  will have more than one peeling option.  E.g., a loop with two
                  types: one of size (vector size / 4), and the other one of
                  size (vector size / 8).  Vectorization factor will 8.  If both
-                 access are misaligned by 3, the first one needs one scalar
+                 accesses are misaligned by 3, the first one needs one scalar
                  iteration to be aligned, and the second one needs 5.  But the
                 first one will be aligned also by peeling 5 scalar
                  iterations, and in that case both accesses will be aligned.
                  Hence, except for the immediate peeling amount, we also want
                  to try to add full vector size, while we don't exceed
                  vectorization factor.
-                 We do this automatically for cost model, since we calculate cost
-                 for every peeling option.  */
+                 We do this automatically for cost model, since we calculate
+                cost for every peeling option.  */
               if (unlimited_cost_model (LOOP_VINFO_LOOP (loop_vinfo)))
                {
                  if (STMT_SLP_TYPE (stmt_info))
@@ -1559,17 +1559,15 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
                      = (vf * GROUP_SIZE (stmt_info)) / nelements;
                  else
                    possible_npeel_number = vf / nelements;
-               }
 
-              /* Handle the aligned case. We may decide to align some other
-                 access, making DR unaligned.  */
-              if (DR_MISALIGNMENT (dr) == 0)
-                {
-                  npeel_tmp = 0;
-                  if (unlimited_cost_model (LOOP_VINFO_LOOP (loop_vinfo)))
-                    possible_npeel_number++;
-                }
+                 /* NPEEL_TMP is 0 when there is no misalignment, increment
+                    the peeling amount by one in order to ...  */
+                 if (DR_MISALIGNMENT (dr) == 0)
+                   possible_npeel_number++;
+               }
 
+             /* Save info about DR in the hash table.  Also include peeling
+                amounts according to the explanation above.  */
               for (j = 0; j < possible_npeel_number; j++)
                 {
                   vect_peeling_hash_insert (&peeling_htab, loop_vinfo,
@@ -3884,7 +3882,7 @@ vect_duplicate_ssa_name_ptr_info (tree name, data_reference *dr,
   duplicate_ssa_name_ptr_info (name, DR_PTR_INFO (dr));
   unsigned int align = TYPE_ALIGN_UNIT (STMT_VINFO_VECTYPE (stmt_info));
   int misalign = DR_MISALIGNMENT (dr);
-  if (misalign == -1)
+  if (misalign == DR_MISALIGNMENT_UNKNOWN)
     mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (name));
   else
     set_ptr_info_alignment (SSA_NAME_PTR_INFO (name), align, misalign);

diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h
index eb47bd4f7ef6f0d692618779265fe4cb5f105ff7..dfbe59eb10d68b9c3d6b75bf2a33bc040c3105a3 100644 (file)
--- a/gcc/tree-vectorizer.h
+++ b/gcc/tree-vectorizer.h
@@ -984,6 +984,7 @@ dr_misalignment (struct data_reference *dr)
    taking into account peeling/versioning if applied.  */
 #define DR_MISALIGNMENT(DR) dr_misalignment (DR)
 #define SET_DR_MISALIGNMENT(DR, VAL) set_dr_misalignment (DR, VAL)
+#define DR_MISALIGNMENT_UNKNOWN (-1)
 
 /* Return TRUE if the data access is aligned, and FALSE otherwise.  */
 
@@ -999,7 +1000,7 @@ aligned_access_p (struct data_reference *data_ref_info)
 static inline bool
 known_alignment_for_access_p (struct data_reference *data_ref_info)
 {
-  return (DR_MISALIGNMENT (data_ref_info) != -1);
+  return (DR_MISALIGNMENT (data_ref_info) != DR_MISALIGNMENT_UNKNOWN);
 }