From 4db34072d5336d13b66f7185ec6454aa7d36f3c7 Mon Sep 17 00:00:00 2001
From: Kewen Lin <linkw@linux.ibm.com>
Date: Mon, 7 Jun 2021 22:10:33 -0500
Subject: [PATCH] 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.
---
gcc/testsuite/gcc.dg/tree-ssa/pr100794.c | 20 ++++++++++
gcc/tree-predcom.c | 50 ++++++++++++++++--------
2 files changed, 54 insertions(+), 16 deletions(-)
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr100794.c
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 000000000000..6f707ae7fba3
--- /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 02f911a08bb1..ac1674d54861 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
--
GitLab