Re: [PATCH] Check calls before loop unrolling

[Jiufu Guo <guojiufu@linux.ibm.com>]

guojiufu <guojiufu@linux.ibm.com> writes:

Hi,

In this patch, the default value of
param=max-unrolled-average-calls-x10000 is '0', which means to unroll
a loop, there should be no call inside the body.  Do I need to set the
default value to a bigger value (16?) for later tune?  Biger value will
keep the behavior unchanged.

And is this patch ok for trunk?  Thanks a lot for you comments!

BR.
Jiufu.


> Hi,
>
> When unroll loops, if there are calls inside the loop, those calls
> may raise negative impacts for unrolling.  This patch adds a param
> param_max_unrolled_calls, and checks if the number of calls inside
> the loop bigger than this param, loop is prevent from unrolling.
>
> This patch is checking the _average_ number of calls which is the
> summary of call numbers multiply the possibility of the call maybe
> executed.  The _average_ number could be a fraction, to keep the
> precision, the param is the threshold number multiply 10000.
>
> Bootstrap and regtest pass on powerpc64le.  Is this ok for trunk?
>
> gcc/ChangeLog
> 2020-08-19  Jiufu Guo   <guojiufu@cn.ibm.com>
>
> 	* params.opt (param_max_unrolled_average_calls_x10000): New param.
> 	* cfgloop.h (average_num_loop_calls): New declare.
> 	* cfgloopanal.c (average_num_loop_calls): New function.
> 	* loop-unroll.c (decide_unroll_constant_iteration,
> 	decide_unroll_runtime_iterations,
> 	decide_unroll_stupid): Check average_num_loop_calls and
> 	param_max_unrolled_average_calls_x10000.
> ---
>  gcc/cfgloop.h     |  2 ++
>  gcc/cfgloopanal.c | 25 +++++++++++++++++++++++++
>  gcc/loop-unroll.c | 10 ++++++++++
>  gcc/params.opt    |  4 ++++
>  4 files changed, 41 insertions(+)
>
> diff --git a/gcc/cfgloop.h b/gcc/cfgloop.h
> index 18b404e292f..dab933da150 100644
> --- a/gcc/cfgloop.h
> +++ b/gcc/cfgloop.h
> @@ -21,6 +21,7 @@ along with GCC; see the file COPYING3.  If not see
>  #define GCC_CFGLOOP_H
>  
>  #include "cfgloopmanip.h"
> +#include "sreal.h"
>  
>  /* Structure to hold decision about unrolling/peeling.  */
>  enum lpt_dec
> @@ -387,6 +388,7 @@ extern vec<edge> get_loop_exit_edges (const class loop *, basic_block * = NULL);
>  extern edge single_exit (const class loop *);
>  extern edge single_likely_exit (class loop *loop, vec<edge>);
>  extern unsigned num_loop_branches (const class loop *);
> +extern sreal average_num_loop_calls (const class loop *);
>  
>  extern edge loop_preheader_edge (const class loop *);
>  extern edge loop_latch_edge (const class loop *);
> diff --git a/gcc/cfgloopanal.c b/gcc/cfgloopanal.c
> index 0b33e8272a7..a314db4e0c0 100644
> --- a/gcc/cfgloopanal.c
> +++ b/gcc/cfgloopanal.c
> @@ -233,6 +233,31 @@ average_num_loop_insns (const class loop *loop)
>    return ret;
>  }
>  
> +/* Count the number of call insns in LOOP.  */
> +sreal
> +average_num_loop_calls (const class loop *loop)
> +{
> +  basic_block *bbs;
> +  rtx_insn *insn;
> +  unsigned int i, bncalls;
> +  sreal ncalls = 0;
> +
> +  bbs = get_loop_body (loop);
> +  for (i = 0; i < loop->num_nodes; i++)
> +    {
> +      bncalls = 0;
> +      FOR_BB_INSNS (bbs[i], insn)
> +	if (CALL_P (insn))
> +	  bncalls++;
> +
> +      ncalls += (sreal) bncalls
> +	* bbs[i]->count.to_sreal_scale (loop->header->count);
> +    }
> +  free (bbs);
> +
> +  return ncalls;
> +}
> +
>  /* Returns expected number of iterations of LOOP, according to
>     measured or guessed profile.
>  
> diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c
> index 693c7768868..56b8fb37d2a 100644
> --- a/gcc/loop-unroll.c
> +++ b/gcc/loop-unroll.c
> @@ -370,6 +370,10 @@ decide_unroll_constant_iterations (class loop *loop, int flags)
>      nunroll = nunroll_by_av;
>    if (nunroll > (unsigned) param_max_unroll_times)
>      nunroll = param_max_unroll_times;
> +  if (!loop->unroll
> +      && (average_num_loop_calls (loop) * (sreal) 10000).to_int ()
> +	   > (unsigned) param_max_unrolled_average_calls_x10000)
> +    nunroll = 0;
>  
>    if (targetm.loop_unroll_adjust)
>      nunroll = targetm.loop_unroll_adjust (nunroll, loop);
> @@ -689,6 +693,9 @@ decide_unroll_runtime_iterations (class loop *loop, int flags)
>      nunroll = nunroll_by_av;
>    if (nunroll > (unsigned) param_max_unroll_times)
>      nunroll = param_max_unroll_times;
> +  if ((average_num_loop_calls (loop) * (sreal) 10000).to_int ()
> +      > (unsigned) param_max_unrolled_average_calls_x10000)
> +    nunroll = 0;
>  
>    if (targetm.loop_unroll_adjust)
>      nunroll = targetm.loop_unroll_adjust (nunroll, loop);
> @@ -1173,6 +1180,9 @@ decide_unroll_stupid (class loop *loop, int flags)
>      nunroll = nunroll_by_av;
>    if (nunroll > (unsigned) param_max_unroll_times)
>      nunroll = param_max_unroll_times;
> +  if ((average_num_loop_calls (loop) * (sreal) 10000).to_int ()
> +      > (unsigned) param_max_unrolled_average_calls_x10000)
> +    nunroll = 0;
>  
>    if (targetm.loop_unroll_adjust)
>      nunroll = targetm.loop_unroll_adjust (nunroll, loop);
> diff --git a/gcc/params.opt b/gcc/params.opt
> index f39e5d1a012..80605861223 100644
> --- a/gcc/params.opt
> +++ b/gcc/params.opt
> @@ -634,6 +634,10 @@ The maximum number of unrollings of a single loop.
>  Common Joined UInteger Var(param_max_unrolled_insns) Init(200) Param Optimization
>  The maximum number of instructions to consider to unroll in a loop.
>  
> +-param=max-unrolled-average-calls-x10000=
> +Common Joined UInteger Var(param_max_unrolled_average_calls_x10000) Init(0) Param Optimization
> +The maximum number of calls to consider to unroll in a loop on average and multiply 10000.
> +
>  -param=max-unswitch-insns=
>  Common Joined UInteger Var(param_max_unswitch_insns) Init(50) Param Optimization
>  The maximum number of insns of an unswitched loop.