[gcc r12-1275] predcom: Enabled by loop vect at O2 [PR100794]

[gcc r12-1275] predcom: Enabled by loop vect at O2 [PR100794]

[Kewen Lin]

https://gcc.gnu.org/g:4db34072d5336d13b66f7185ec6454aa7d36f3c7

commit r12-1275-g4db34072d5336d13b66f7185ec6454aa7d36f3c7
Author: Kewen Lin <linkw@linux.ibm.com>
Date:   Mon Jun 7 22:10:33 2021 -0500

    predcom: Enabled by loop vect at O2 [PR100794]
    
    As PR100794 shows, in the current implementation PRE bypasses
    some optimization to avoid introducing loop carried dependence
    which stops loop vectorizer to vectorize the loop.  At -O2,
    there is no downstream pass to re-catch this kind of opportunity
    if loop vectorizer fails to vectorize that loop.
    
    This patch follows Richi's suggestion in the PR, if predcom flag
    isn't set and loop vectorization will enable predcom without any
    unrolling implicitly.  The Power9 SPEC2017 evaluation showed it
    can speed up 521.wrf_r 3.30% and 554.roms_r 1.08% at very-cheap
    cost model, no remarkable impact at cheap cost model, the build
    time and size impact is fine (see the PR for the details).
    
    By the way, I tested another proposal to guard PRE not skip the
    optimization for cheap and very-cheap vect cost models, the
    evaluation results showed it's fine with very cheap cost model,
    but it can degrade some bmks like 521.wrf_r -9.17% and
    549.fotonik3d_r -2.07% etc.
    
    Bootstrapped/regtested on powerpc64le-linux-gnu P9,
    x86_64-redhat-linux and aarch64-linux-gnu.
    
    gcc/ChangeLog:
    
            PR tree-optimization/100794
            * tree-predcom.c (tree_predictive_commoning_loop): Add parameter
            allow_unroll_p and only allow unrolling when it's true.
            (tree_predictive_commoning): Add parameter allow_unroll_p and
            adjust for it.
            (run_tree_predictive_commoning): Likewise.
            (pass_predcom::gate): Check flag_tree_loop_vectorize and
            global_options_set.x_flag_predictive_commoning.
            (pass_predcom::execute): Adjust for allow_unroll_p.
    
    gcc/testsuite/ChangeLog:
    
            PR tree-optimization/100794
            * gcc.dg/tree-ssa/pr100794.c: New test.

Diff:
---
 gcc/testsuite/gcc.dg/tree-ssa/pr100794.c | 20 +++++++++++++
 gcc/tree-predcom.c                       | 50 ++++++++++++++++++++++----------
 2 files changed, 54 insertions(+), 16 deletions(-)

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr100794.c b/gcc/testsuite/gcc.dg/tree-ssa/pr100794.c
new file mode 100644
index 00000000000..6f707ae7fba
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr100794.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-vectorize -fdump-tree-pcom-details -fdisable-tree-vect" } */
+
+extern double arr[100];
+extern double foo (double, double);
+extern double sum;
+
+void
+test (int i_0, int i_n)
+{
+  int i;
+  for (i = i_0; i < i_n - 1; i++)
+    {
+      double a = arr[i];
+      double b = arr[i + 1];
+      sum += a * b;
+    }
+}
+
+/* { dg-final { scan-tree-dump "Executing predictive commoning without unrolling" "pcom" } } */
diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c
index 02f911a08bb..ac1674d5486 100644
--- a/gcc/tree-predcom.c
+++ b/gcc/tree-predcom.c
@@ -3178,13 +3178,13 @@ insert_init_seqs (class loop *loop, vec<chain_p> chains)
    applied to this loop.  */
 
 static unsigned
-tree_predictive_commoning_loop (class loop *loop)
+tree_predictive_commoning_loop (class loop *loop, bool allow_unroll_p)
 {
   vec<data_reference_p> datarefs;
   vec<ddr_p> dependences;
   struct component *components;
   vec<chain_p> chains = vNULL;
-  unsigned unroll_factor;
+  unsigned unroll_factor = 0;
   class tree_niter_desc desc;
   bool unroll = false, loop_closed_ssa = false;
 
@@ -3272,11 +3272,13 @@ tree_predictive_commoning_loop (class loop *loop)
       dump_chains (dump_file, chains);
     }
 
-  /* Determine the unroll factor, and if the loop should be unrolled, ensure
-     that its number of iterations is divisible by the factor.  */
-  unroll_factor = determine_unroll_factor (chains);
-  unroll = (unroll_factor > 1
-	    && can_unroll_loop_p (loop, unroll_factor, &desc));
+  if (allow_unroll_p)
+    /* Determine the unroll factor, and if the loop should be unrolled, ensure
+       that its number of iterations is divisible by the factor.  */
+    unroll_factor = determine_unroll_factor (chains);
+
+  if (unroll_factor > 1)
+    unroll = can_unroll_loop_p (loop, unroll_factor, &desc);
 
   /* Execute the predictive commoning transformations, and possibly unroll the
      loop.  */
@@ -3319,7 +3321,7 @@ tree_predictive_commoning_loop (class loop *loop)
 /* Runs predictive commoning.  */
 
 unsigned
-tree_predictive_commoning (void)
+tree_predictive_commoning (bool allow_unroll_p)
 {
   class loop *loop;
   unsigned ret = 0, changed = 0;
@@ -3328,7 +3330,7 @@ tree_predictive_commoning (void)
   FOR_EACH_LOOP (loop, LI_ONLY_INNERMOST)
     if (optimize_loop_for_speed_p (loop))
       {
-	changed |= tree_predictive_commoning_loop (loop);
+	changed |= tree_predictive_commoning_loop (loop, allow_unroll_p);
       }
   free_original_copy_tables ();
 
@@ -3355,12 +3357,12 @@ tree_predictive_commoning (void)
 /* Predictive commoning Pass.  */
 
 static unsigned
-run_tree_predictive_commoning (struct function *fun)
+run_tree_predictive_commoning (struct function *fun, bool allow_unroll_p)
 {
   if (number_of_loops (fun) <= 1)
     return 0;
 
-  return tree_predictive_commoning ();
+  return tree_predictive_commoning (allow_unroll_p);
 }
 
 namespace {
@@ -3386,11 +3388,27 @@ public:
   {}
 
   /* opt_pass methods: */
-  virtual bool gate (function *) { return flag_predictive_commoning != 0; }
-  virtual unsigned int execute (function *fun)
-    {
-      return run_tree_predictive_commoning (fun);
-    }
+  virtual bool
+  gate (function *)
+  {
+    if (flag_predictive_commoning != 0)
+      return true;
+    /* Loop vectorization enables predictive commoning implicitly
+       only if predictive commoning isn't set explicitly, and it
+       doesn't allow unrolling.  */
+    if (flag_tree_loop_vectorize
+	&& !global_options_set.x_flag_predictive_commoning)
+      return true;
+
+    return false;
+  }
+
+  virtual unsigned int
+  execute (function *fun)
+  {
+    bool allow_unroll_p = flag_predictive_commoning != 0;
+    return run_tree_predictive_commoning (fun, allow_unroll_p);
+  }
 
 }; // class pass_predcom