[PATCH][cunroll] Add unroll-known-loop-iterations-only param and use it in aarch64

[Kyrill Tkachov <kyrylo dot tkachov at foss dot arm dot com>]

Hi all,

In this testcase the codegen for VLA SVE is worse than it could be due to unrolling:

fully_peel_me:
        mov     x1, 5
        ptrue   p1.d, all
        whilelo p0.d, xzr, x1
        ld1d    z0.d, p0/z, [x0]
        fadd    z0.d, z0.d, z0.d
        st1d    z0.d, p0, [x0]
        cntd    x2
        addvl   x3, x0, #1
        whilelo p0.d, x2, x1
        beq     .L1
        ld1d    z0.d, p0/z, [x0, #1, mul vl]
        fadd    z0.d, z0.d, z0.d
        st1d    z0.d, p0, [x3]
        cntw    x2
        incb    x0, all, mul #2
        whilelo p0.d, x2, x1
        beq     .L1
        ld1d    z0.d, p0/z, [x0]
        fadd    z0.d, z0.d, z0.d
        st1d    z0.d, p0, [x0]
.L1:
        ret

In this case, due to the vector-length-agnostic nature of SVE the compiler doesn't know the loop iteration count.
For such loops we don't want to unroll if we don't end up eliminating branches as this just bloats code size
and hurts icache performance.

This patch introduces a new unroll-known-loop-iterations-only param that disables cunroll when the loop iteration
count is unknown (SCEV_NOT_KNOWN). This case occurs much more often for SVE VLA code, but it does help some
Advanced SIMD cases as well where loops with an unknown iteration count are not unrolled when it doesn't eliminate
the branches.

So for the above testcase we generate now:
fully_peel_me:
        mov     x2, 5
        mov     x3, x2
        mov     x1, 0
        whilelo p0.d, xzr, x2
        ptrue   p1.d, all
.L2:
        ld1d    z0.d, p0/z, [x0, x1, lsl 3]
        fadd    z0.d, z0.d, z0.d
        st1d    z0.d, p0, [x0, x1, lsl 3]
        incd    x1
        whilelo p0.d, x1, x3
        bne     .L2
        ret

Not perfect still, but it's preferable to the original code.
The new param is enabled by default on aarch64 but disabled for other targets, leaving their behaviour unchanged
(until other target people experiment with it and set it, if appropriate).

Bootstrapped and tested on aarch64-none-linux-gnu.
Benchmarked on SPEC2017 on a Cortex-A57 and there are no differences in performance.

Ok for trunk?
Thanks,
Kyrill


2018-11-09  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>

	* params.def (PARAM_UNROLL_KNOWN_LOOP_ITERATIONS_ONLY): Define.
	* tree-ssa-loop-ivcanon.c (try_unroll_loop_completely): Use above to
	disable unrolling on unknown iteration count.
	* config/aarch64/aarch64.c (aarch64_override_options_internal): Set
	PARAM_UNROLL_KNOWN_LOOP_ITERATIONS_ONLY to 1.
	* doc/invoke.texi (--param unroll-known-loop-iterations-only):
	Document.

2018-11-09  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>

	* gcc.target/aarch64/sve/unroll-1.c: New test.

diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
index f0e54eda80656829528c018357dde2e1e87f6ebd..34d08a075221fd4c098e9b5e8fabd8fe3948d285 100644
--- a/gcc/config/aarch64/aarch64.c
+++ b/gcc/config/aarch64/aarch64.c
@@ -10993,6 +10993,12 @@ aarch64_override_options_internal (struct gcc_options *opts)
 			 opts->x_param_values,
 			 global_options_set.x_param_values);
 
+  /* Don't unroll loops where the exact iteration count is not known at
+     compile-time.  */
+  maybe_set_param_value (PARAM_UNROLL_KNOWN_LOOP_ITERATIONS_ONLY, 1,
+			 opts->x_param_values,
+			 global_options_set.x_param_values);
+
   /* If the user hasn't changed it via configure then set the default to 64 KB
      for the backend.  */
   maybe_set_param_value (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE,
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 802cc642453aef2d2c516bcbda22246252ec87c1..74e2aeda27d718264188761cf522d6c9f8025e07 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -10732,6 +10732,9 @@ The maximum number of branches on the hot path through the peeled sequence.
 @item max-completely-peeled-insns
 The maximum number of insns of a completely peeled loop.
 
+@item unroll-known-loop-iterations-only
+Only completely unroll loops where the iteration count is known.
+
 @item max-completely-peel-times
 The maximum number of iterations of a loop to be suitable for complete peeling.
 
diff --git a/gcc/params.def b/gcc/params.def
index 4a5f2042dac72bb457488ac8bc35d09df94c929c..07946552232058cee41303e81ed694f7f0bb615e 100644
--- a/gcc/params.def
+++ b/gcc/params.def
@@ -344,6 +344,11 @@ DEFPARAM(PARAM_MAX_UNROLL_ITERATIONS,
 	 "The maximum depth of a loop nest we completely peel.",
 	 8, 0, 0)
 
+DEFPARAM(PARAM_UNROLL_KNOWN_LOOP_ITERATIONS_ONLY,
+	 "unroll-known-loop-iterations-only",
+	 "Only completely unroll loops where the iteration count is known",
+	 0, 0, 1)
+
 /* The maximum number of insns of an unswitched loop.  */
 DEFPARAM(PARAM_MAX_UNSWITCH_INSNS,
 	"max-unswitch-insns",
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/unroll-1.c b/gcc/testsuite/gcc.target/aarch64/sve/unroll-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..7f53d20cbf8e18a4389b86c037f56f024bac22a5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/sve/unroll-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+
+/* Check that simple loop is not fully unrolled.  */
+
+void
+fully_peel_me (double *x)
+{
+  for (int i = 0; i < 5; i++)
+    x[i] = x[i] * 2;
+}
+
+/* { dg-final { scan-assembler-times {\tld1d\tz[0-9]+\.d, p[0-7]/z, \[.+]\n} 1 } } */
+/* { dg-final { scan-assembler-times {\tst1d\tz[0-9]+\.d, p[0-7], \[.+\]\n} 1 } } */
diff --git a/gcc/tree-ssa-loop-ivcanon.c b/gcc/tree-ssa-loop-ivcanon.c
index eeae2a8c54af14e58970d1797c92ecc86ac0523c..a67800fe8807ba003c05c3d8bdd820cc8df93e57 100644
--- a/gcc/tree-ssa-loop-ivcanon.c
+++ b/gcc/tree-ssa-loop-ivcanon.c
@@ -883,6 +883,17 @@ try_unroll_loop_completely (struct loop *loop,
 			 loop->num);
 	      return false;
 	    }
+	  else if (TREE_CODE (niter) == SCEV_NOT_KNOWN
+		   && PARAM_VALUE (PARAM_UNROLL_KNOWN_LOOP_ITERATIONS_ONLY)
+		      == 1)
+	    {
+	      if (dump_file && (dump_flags & TDF_DETAILS))
+		fprintf (dump_file, "Not unrolling loop %d: "
+			 "exact number of iterations not known "
+			 "(--param unroll-known-loop-iterations-only).\n",
+			 loop->num);
+	      return false;
+	    }
 	}
 
       initialize_original_copy_tables ();