[RFC] Heuristics to throttle the complette unrolling

Hi,
for past week or two I was playing with ways to throttle down the complette
unrolling heuristics.  I made complette unroller to use the tree-ssa-loop-niter
upper bound and unroll even in non-trivial cases and this has turned out to
increase number of complettely unrolled loops by great amount, so one can
see it as considerable code size growth at -O3 SPEC build.

http://gcc.opensuse.org/SPEC/CFP/sb-vangelis-head-64/Total-size_big.png
it is the largest jump on right hand side in both peak and base runs.
There are also performance imrovements, most impotantly 11% on applu.

The intuition is that complette unrolling is most profitable when IV tests
are eliminated and single basic block is created. When condtionals stay
in the code it is not that good idea and also functions containing calls
are less interesting for unrolling since the calls are slow and optimization
oppurtunities are not so great.

This patch reduces unrolling on loops having many branches or calls on the
hot patch.  I found that for applu speedup the number of branches needs to be
pretty high - about 32.

The patch saves about half of the growth introduced (but on different benchmarks)
and I think I can move all peeling to trees and reduce peeling limits a bit, too.

Does this sound sane? Any ideas?

Honza

On Tue, 30 Oct 2012, Jan Hubicka wrote:

> Hi,
> for past week or two I was playing with ways to throttle down the complette
> unrolling heuristics.  I made complette unroller to use the tree-ssa-loop-niter
> upper bound and unroll even in non-trivial cases and this has turned out to
> increase number of complettely unrolled loops by great amount, so one can
> see it as considerable code size growth at -O3 SPEC build.
> 
> http://gcc.opensuse.org/SPEC/CFP/sb-vangelis-head-64/Total-size_big.png
> it is the largest jump on right hand side in both peak and base runs.
> There are also performance imrovements, most impotantly 11% on applu.
> 
> The intuition is that complette unrolling is most profitable when IV tests
> are eliminated and single basic block is created. When condtionals stay
> in the code it is not that good idea and also functions containing calls
> are less interesting for unrolling since the calls are slow and optimization
> oppurtunities are not so great.
> 
> This patch reduces unrolling on loops having many branches or calls on the
> hot patch.  I found that for applu speedup the number of branches needs to be
> pretty high - about 32.
> 
> The patch saves about half of the growth introduced (but on different benchmarks)
> and I think I can move all peeling to trees and reduce peeling limits a bit, too.
> 
> Does this sound sane? Any ideas?

Yes, this sounds ok (beware of unrelated PARAM_MAX_ONCE_PEELED_INSNS
remove in the patch below).

Richard.

> Honza
> 
> Index: tree-ssa-loop-ivcanon.c
> ===================================================================
> --- tree-ssa-loop-ivcanon.c	(revision 192892)
> +++ tree-ssa-loop-ivcanon.c	(working copy)
> @@ -140,6 +140,20 @@ struct loop_size
>       instructions after exit are not executed.  */
>    int last_iteration;
>    int last_iteration_eliminated_by_peeling;
> +  
> +  /* If some IV computation will become constant.  */
> +  bool constant_iv;
> +
> +  /* Number of call stmts that are not a builtin and are pure or const
> +     present on the hot path.  */
> +  int num_pure_calls_on_hot_path;
> +  /* Number of call stmts that are not a builtin and are not pure nor const
> +     present on the hot path.  */
> +  int num_non_pure_calls_on_hot_path;
> +  /* Number of statements other than calls in the loop.  */
> +  int non_call_stmts_on_hot_path;
> +  /* Number of branches seen on the hot path.  */
> +  int num_branches_on_hot_path;
>  };
>  
>  /* Return true if OP in STMT will be constant after peeling LOOP.  */
> @@ -188,7 +202,11 @@ constant_after_peeling (tree op, gimple
>    return true;
>  }
>  
> -/* Computes an estimated number of insns in LOOP, weighted by WEIGHTS.
> +/* Computes an estimated number of insns in LOOP.
> +   EXIT (if non-NULL) is an exite edge that will be eliminated in all but last
> +   iteration of the loop.
> +   EDGE_TO_CANCEL (if non-NULL) is an non-exit edge eliminated in the last iteration
> +   of loop.
>     Return results in SIZE, estimate benefits for complete unrolling exiting by EXIT.  */
>  
>  static void
> @@ -198,11 +216,17 @@ tree_estimate_loop_size (struct loop *lo
>    gimple_stmt_iterator gsi;
>    unsigned int i;
>    bool after_exit;
> +  VEC (basic_block, heap) *path = get_loop_hot_path (loop);
>  
>    size->overall = 0;
>    size->eliminated_by_peeling = 0;
>    size->last_iteration = 0;
>    size->last_iteration_eliminated_by_peeling = 0;
> +  size->num_pure_calls_on_hot_path = 0;
> +  size->num_non_pure_calls_on_hot_path = 0;
> +  size->non_call_stmts_on_hot_path = 0;
> +  size->num_branches_on_hot_path = 0;
> +  size->constant_iv = 0;
>  
>    if (dump_file && (dump_flags & TDF_DETAILS))
>      fprintf (dump_file, "Estimating sizes for loop %i\n", loop->num);
> @@ -221,6 +245,8 @@ tree_estimate_loop_size (struct loop *lo
>  	  gimple stmt = gsi_stmt (gsi);
>  	  int num = estimate_num_insns (stmt, &eni_size_weights);
>  	  bool likely_eliminated = false;
> +	  bool likely_eliminated_last = false;
> +	  bool likely_eliminated_peeled = false;
>  
>  	  if (dump_file && (dump_flags & TDF_DETAILS))
>  	    {
> @@ -231,11 +257,21 @@ tree_estimate_loop_size (struct loop *lo
>  	  /* Look for reasons why we might optimize this stmt away. */
>  
>  	  /* Exit conditional.  */
> -	  if (exit && body[i] == exit->src && stmt == last_stmt (exit->src))
> +	  if (exit && body[i] == exit->src
> +		   && stmt == last_stmt (exit->src))
>  	    {
>  	      if (dump_file && (dump_flags & TDF_DETAILS))
> -	        fprintf (dump_file, "   Exit condition will be eliminated.\n");
> -	      likely_eliminated = true;
> +	        fprintf (dump_file, "   Exit condition will be eliminated "
> +			 "in peeled copies.\n");
> +	      likely_eliminated_peeled = true;
> +	    }
> +	  else if (edge_to_cancel && body[i] == edge_to_cancel->src
> +		   && stmt == last_stmt (edge_to_cancel->src))
> +	    {
> +	      if (dump_file && (dump_flags & TDF_DETAILS))
> +	        fprintf (dump_file, "   Exit condition will be eliminated "
> +			 "in last copy.\n");
> +	      likely_eliminated_last = true;
>  	    }
>  	  /* Sets of IV variables  */
>  	  else if (gimple_code (stmt) == GIMPLE_ASSIGN
> @@ -249,19 +285,22 @@ tree_estimate_loop_size (struct loop *lo
>  	  /* Assignments of IV variables.  */
>  	  else if (gimple_code (stmt) == GIMPLE_ASSIGN
>  		   && TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME
> -		   && constant_after_peeling (gimple_assign_rhs1 (stmt), stmt,loop)
> +		   && constant_after_peeling (gimple_assign_rhs1 (stmt), stmt, loop)
>  		   && (gimple_assign_rhs_class (stmt) != GIMPLE_BINARY_RHS
>  		       || constant_after_peeling (gimple_assign_rhs2 (stmt),
>  		       				  stmt, loop)))
>  	    {
> +	      size->constant_iv = true;
>  	      if (dump_file && (dump_flags & TDF_DETAILS))
>  	        fprintf (dump_file, "   Constant expression will be folded away.\n");
>  	      likely_eliminated = true;
>  	    }
>  	  /* Conditionals.  */
> -	  else if (gimple_code (stmt) == GIMPLE_COND
> -		   && constant_after_peeling (gimple_cond_lhs (stmt), stmt, loop)
> -		   && constant_after_peeling (gimple_cond_rhs (stmt), stmt, loop))
> +	  else if ((gimple_code (stmt) == GIMPLE_COND
> +		    && constant_after_peeling (gimple_cond_lhs (stmt), stmt, loop)
> +		    && constant_after_peeling (gimple_cond_rhs (stmt), stmt, loop))
> +		   || (gimple_code (stmt) == GIMPLE_SWITCH
> +		       && constant_after_peeling (gimple_switch_index (stmt), stmt, loop)))
>  	    {
>  	      if (dump_file && (dump_flags & TDF_DETAILS))
>  	        fprintf (dump_file, "   Constant conditional.\n");
> @@ -269,16 +308,48 @@ tree_estimate_loop_size (struct loop *lo
>  	    }
>  
>  	  size->overall += num;
> -	  if (likely_eliminated)
> +	  if (likely_eliminated || likely_eliminated_peeled)
>  	    size->eliminated_by_peeling += num;
>  	  if (!after_exit)
>  	    {
>  	      size->last_iteration += num;
> -	      if (likely_eliminated)
> +	      if (likely_eliminated || likely_eliminated_last)
>  		size->last_iteration_eliminated_by_peeling += num;
>  	    }
>  	}
>      }
> +  while (VEC_length (basic_block, path))
> +    {
> +      basic_block bb = VEC_pop (basic_block, path);
> +      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
> +	{
> +	  gimple stmt = gsi_stmt (gsi);
> +	  if (gimple_code (stmt) == GIMPLE_CALL)
> +	    {
> +	      int flags = gimple_call_flags (stmt);
> +	      tree decl = gimple_call_fndecl (stmt);
> +
> +	      if (decl && DECL_IS_BUILTIN (decl))
> +		;
> +	      else if (flags & (ECF_PURE | ECF_CONST))
> +		size->num_pure_calls_on_hot_path++;
> +	      else
> +		size->num_non_pure_calls_on_hot_path++;
> +	      size->num_branches_on_hot_path ++;
> +	    }
> +	  else if (gimple_code (stmt) != GIMPLE_CALL
> +		   && gimple_code (stmt) != GIMPLE_DEBUG)
> +	    size->non_call_stmts_on_hot_path++;
> +	  if (((gimple_code (stmt) == GIMPLE_COND
> +	        && (!constant_after_peeling (gimple_cond_lhs (stmt), stmt, loop)
> +		    || constant_after_peeling (gimple_cond_rhs (stmt), stmt, loop)))
> +	       || (gimple_code (stmt) == GIMPLE_SWITCH
> +		   && !constant_after_peeling (gimple_switch_index (stmt), stmt, loop)))
> +	      && (!exit || bb != exit->src))
> +	    size->num_branches_on_hot_path++;
> +	}
> +    }
> +  VEC_free (basic_block, heap, path);
>    if (dump_file && (dump_flags & TDF_DETAILS))
>      fprintf (dump_file, "size: %i-%i, last_iteration: %i-%i\n", size->overall,
>      	     size->eliminated_by_peeling, size->last_iteration,
> @@ -486,34 +557,85 @@ try_unroll_loop_completely (struct loop
>  		   (int) unr_insns);
>  	}
>  
> +      /* If the code is going to shrink, we don't need to be extra cautious
> +	 on guessing if the unrolling is going to be profitable.  */
> +      if (unr_insns
> +	  /* If there is IV variable that will become constant, we save
> +	     one instruction in the loop prologue we do not account
> +	     otherwise.  */
> +	  <= ninsns + (size.constant_iv != false))
> +	;
>        /* We unroll only inner loops, because we do not consider it profitable
>  	 otheriwse.  We still can cancel loopback edge of not rolling loop;
>  	 this is always a good idea.  */
> -      if (loop->inner && unr_insns > ninsns)
> +      else if (ul == UL_NO_GROWTH)
> +	{
> +	  if (dump_file && (dump_flags & TDF_DETAILS))
> +	    fprintf (dump_file, "Not unrolling loop %d: size would grow.\n",
> +		     loop->num);
> +	  return false;
> +	}
> +      /* Outer loops tend to be less interesting candidates for complette
> +	 unrolling unless we can do a lot of propagation into the inner loop
> +	 body.  For now we disable outer loop unrolling when the code would
> +	 grow.  */
> +      else if (loop->inner)
>  	{
>  	  if (dump_file && (dump_flags & TDF_DETAILS))
> -	    fprintf (dump_file, "Not unrolling loop %d:"
> +	    fprintf (dump_file, "Not unrolling loop %d: "
>  		     "it is not innermost and code would grow.\n",
>  		     loop->num);
>  	  return false;
>  	}
> -
> -      if (unr_insns > ninsns
> -	  && (unr_insns
> -	      > (unsigned) PARAM_VALUE (PARAM_MAX_COMPLETELY_PEELED_INSNS)))
> +      /* If there is call on a hot path through the loop, then
> +	 there is most probably not much to optimize.  */
> +      else if (size.num_non_pure_calls_on_hot_path)
>  	{
>  	  if (dump_file && (dump_flags & TDF_DETAILS))
> -	    fprintf (dump_file, "Not unrolling loop %d "
> -		     "(--param max-completely-peeled-insns limit reached).\n",
> +	    fprintf (dump_file, "Not unrolling loop %d: "
> +		     "contains call and code would grow.\n",
>  		     loop->num);
>  	  return false;
>  	}
> -
> -      if (ul == UL_NO_GROWTH
> -	  && unr_insns > ninsns)
> +      /* If there is pure/const call in the function, then we
> +	 can still optimize the unrolled loop body if it contains
> +	 some other interesting code than the calls and code
> +	 storing or cumulating the return value.  */
> +      else if (size.num_pure_calls_on_hot_path
> +	       /* One IV increment, one test, one ivtmp store
> +		  and one usefull stmt.  That is about minimal loop
> +		  doing pure call.  */
> +	       && (size.non_call_stmts_on_hot_path
> +		   <= 3 + size.num_pure_calls_on_hot_path))
>  	{
>  	  if (dump_file && (dump_flags & TDF_DETAILS))
> -	    fprintf (dump_file, "Not unrolling loop %d: size would grow.\n",
> +	    fprintf (dump_file, "Not unrolling loop %d: "
> +		     "contains just pure calls and code would grow.\n",
> +		     loop->num);
> +	  return false;
> +	}
> +      /* Complette unrolling is major win when control flow is removed and
> +	 one big basic block is created.  If the loop contains control flow
> +	 the optimization may still be a win because of eliminating the loop
> +	 overhead but it also may blow the branch predictor tables.
> +	 Limit number of branches on the hot path through the peeled
> +	 sequence.  */
> +      else if (size.num_branches_on_hot_path * (int)n_unroll
> +	       > PARAM_VALUE (PARAM_MAX_PEEL_BRANCHES))
> +	{
> +	  if (dump_file && (dump_flags & TDF_DETAILS))
> +	    fprintf (dump_file, "Not unrolling loop %d: "
> +		     " number of branches on hot path in the unrolled sequence"
> +		     " reach --param max-peel-branches limit.\n",
> +		     loop->num);
> +	  return false;
> +	}
> +      else if (unr_insns
> +	       > (unsigned) PARAM_VALUE (PARAM_MAX_COMPLETELY_PEELED_INSNS))
> +	{
> +	  if (dump_file && (dump_flags & TDF_DETAILS))
> +	    fprintf (dump_file, "Not unrolling loop %d: "
> +		     "(--param max-completely-peeled-insns limit reached).\n",
>  		     loop->num);
>  	  return false;
>  	}
> @@ -531,6 +653,8 @@ try_unroll_loop_completely (struct loop
>  	{
>            free_original_copy_tables ();
>  	  free (wont_exit);
> +	  if (dump_file && (dump_flags & TDF_DETAILS))
> +	    fprintf (dump_file, "Failed to duplicate the loop\n");
>  	  return false;
>  	}
>  
> @@ -826,7 +950,7 @@ tree_unroll_loops_completely (bool may_i
>  	{
>  	  struct loop *loop_father = loop_outer (loop);
>  
> -	  if (may_increase_size && optimize_loop_for_speed_p (loop)
> +	  if (may_increase_size && optimize_loop_nest_for_speed_p (loop)
>  	      /* Unroll outermost loops only if asked to do so or they do
>  		 not cause code growth.  */
>  	      && (unroll_outer || loop_outer (loop_father)))
> Index: testsuite/gcc.dg/tree-ssa/loop-1.c
> ===================================================================
> --- testsuite/gcc.dg/tree-ssa/loop-1.c	(revision 192892)
> +++ testsuite/gcc.dg/tree-ssa/loop-1.c	(working copy)
> @@ -17,13 +17,16 @@
>     to the load from the GOT this also contains the name of the funtion so for
>     each call the function name would appear twice.  */
>  /* { dg-options "-O1 -ftree-loop-ivcanon -funroll-loops -fdump-tree-ivcanon-details -fdump-tree-cunroll-details -fdump-tree-optimized -mno-relax-pic-calls" { target mips*-*-* } } */
> -
> -void xxx(void)
> +__attribute__ ((pure))
> +int foo (int x);
> +int xxx(void)
>  {
>    int x = 45;
> +  int sum;
>  
>    while (x >>= 1)
> -    foo ();
> +    sum += foo (x) * 2;
> +  return sum;
>  }
>  
>  /* We should be able to find out that the loop iterates four times and unroll it completely.  */
> Index: testsuite/gcc.dg/tree-ssa/cunroll-7.c
> ===================================================================
> --- testsuite/gcc.dg/tree-ssa/cunroll-7.c	(revision 0)
> +++ testsuite/gcc.dg/tree-ssa/cunroll-7.c	(working copy)
> @@ -0,0 +1,13 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O3 -fdump-tree-cunroll-details" } */
> +int t(int a) __attribute__ ((pure));
> +test(void)
> +{ 
> +  int i;
> +  int s=0;
> +  for (i=0;i<8;i++)
> +    s+= t(i);
> +  return s;
> +}
> +/* { dg-final { scan-tree-dump "Not unrolling.*contains just pure calls and code would grow." "cunroll"} } */
> +/* { dg-final { cleanup-tree-dump "cunroll" } } */
> Index: testsuite/gcc.dg/tree-ssa/cunroll-6.c
> ===================================================================
> --- testsuite/gcc.dg/tree-ssa/cunroll-6.c	(revision 0)
> +++ testsuite/gcc.dg/tree-ssa/cunroll-6.c	(working copy)
> @@ -0,0 +1,10 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O3 -fdump-tree-cunroll-details" } */
> +test(int c)
> +{ 
> +  int i;
> +  for (i=0;i<8;i++)
> +    t();
> +}
> +/* { dg-final { scan-tree-dump "Not unrolling loop.*contains call and code would grow" "cunroll"} } */
> +/* { dg-final { cleanup-tree-dump "cunroll" } } */
> Index: testsuite/gcc.dg/tree-ssa/cunroll-8.c
> ===================================================================
> --- testsuite/gcc.dg/tree-ssa/cunroll-8.c	(revision 0)
> +++ testsuite/gcc.dg/tree-ssa/cunroll-8.c	(working copy)
> @@ -0,0 +1,14 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O3 -fdump-tree-cunroll-details" } */
> +int a[8][5];
> +int
> +test(int c)
> +{ 
> +  int i;
> +  for (i=0;i<c;i++)
> +    if (a[i][1]==1 || a[i][1]==2 || a[i][3]==3 || a[i][4]==4 ||a[i][5]==5)
> +     break;
> +  return i;
> +}
> +/* { dg-final { scan-tree-dump "Not unrolling.*number of branches on hot path" "cunroll"} } */
> +/* { dg-final { cleanup-tree-dump "cunroll" } } */
> Index: testsuite/gcc.dg/tree-ssa/loop-23.c
> ===================================================================
> --- testsuite/gcc.dg/tree-ssa/loop-23.c	(revision 192892)
> +++ testsuite/gcc.dg/tree-ssa/loop-23.c	(working copy)
> @@ -1,24 +1,27 @@
>  /* { dg-do compile } */
>  /* { dg-options "-O2 -funroll-loops -fdump-tree-cunroll-details" } */
>  
> -void bla(int);
> +__attribute__ ((pure))
> +int bla(int);
>  
> -void foo(void)
> +int foo(void)
>  {
>    int i;
> +  int sum;
>  
>    /* This loop used to appear to be too large for unrolling.  */
>    for (i = 0; i < 4; i++)
>      {
> -      bla (i);
> -      bla (2*i);
> -      bla (3*i);
> -      bla (4*i);
> -      bla (5*i);
> -      bla (6*i);
> -      bla (7*i);
> -      bla (8*i);
> +      sum += bla (i);
> +      sum += bla (2*i);
> +      sum += bla (3*i);
> +      sum += bla (4*i);
> +      sum += bla (5*i);
> +      sum += bla (6*i);
> +      sum += bla (7*i);
> +      sum += bla (8*i);
>      }
> +  return sum;
>  }
>  
>  /* { dg-final { scan-tree-dump-times "Unrolled loop 1 completely" 1 "cunroll" } } */
> Index: testsuite/gcc.dg/tree-ssa/cunroll-1.c
> ===================================================================
> --- testsuite/gcc.dg/tree-ssa/cunroll-1.c	(revision 192892)
> +++ testsuite/gcc.dg/tree-ssa/cunroll-1.c	(working copy)
> @@ -1,5 +1,5 @@
>  /* { dg-do compile } */
> -/* { dg-options "-O3 -fdump-tree-cunroll-details" } */
> +/* { dg-options "-O3 -fdump-tree-cunrolli-details" } */
>  int a[2];
>  test(int c)
>  { 
> @@ -10,4 +10,4 @@ test(int c)
>  /* Array bounds says the loop will not roll much.  */
>  /* { dg-final { scan-tree-dump "Unrolled loop 1 completely .duplicated 1 times.." "cunroll"} } */
>  /* { dg-final { scan-tree-dump "Last iteration exit edge was proved true." "cunroll"} } */
> -/* { dg-final { cleanup-tree-dump "cunroll" } } */
> +/* { dg-final { cleanup-tree-dump "cunrolli" } } */
> Index: testsuite/gcc.dg/unroll_6.c
> ===================================================================
> --- testsuite/gcc.dg/unroll_6.c	(revision 0)
> +++ testsuite/gcc.dg/unroll_6.c	(working copy)
> @@ -0,0 +1,18 @@
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-rtl-loop2_unroll -fno-peel-loops -fdisable-tree-cunroll -fdisable-tree-cunrolli -funroll-loops" } */
> +
> +int a[2];
> +test(int c)
> +{ 
> +  int i;
> +  for (i=0;i<c;i++)
> +    {
> +      a[i]=5;
> +      if (test2())
> +	return;
> +    }
> +}
> +
> +/* { dg-final { scan-rtl-dump-times "Decided to peel loop completely" 1 "loop2_unroll" } } */
> +/* { dg-final { scan-rtl-dump-times "Peeled loop completely, 2 times" 1 "loop2_unroll" } } */
> +/* { dg-final { cleanup-rtl-dump "loop2_unroll" } } */
> Index: testsuite/gcc.dg/tree-prof/unroll-1.c
> ===================================================================
> --- testsuite/gcc.dg/tree-prof/unroll-1.c	(revision 192892)
> +++ testsuite/gcc.dg/tree-prof/unroll-1.c	(working copy)
> @@ -21,4 +21,3 @@ main()
>  }
>  /* { dg-final-use { scan-rtl-dump "Considering unrolling loop with constant number of iterations" "loop2_unroll" } } */
>  /* { dg-final-use { cleanup-rtl-dump "Not unrolling loop, doesn't roll" } } */
> -/* { dg-options "-O3 -fdump-rtl-loop2_unroll -funroll-loops -fno-peel-loops" } */
> Index: params.def
> ===================================================================
> --- params.def	(revision 192892)
> +++ params.def	(working copy)
> @@ -301,11 +306,11 @@ DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES
>  	"max-completely-peel-times",
>  	"The maximum number of peelings of a single loop that is peeled completely",
>  	16, 0, 0)
> -/* The maximum number of insns of a peeled loop that rolls only once.  */
> -DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS,
> -	"max-once-peeled-insns",
> -	"The maximum number of insns of a peeled loop that rolls only once",
> -	400, 0, 0)
> +/* The maximum number of peelings of a single loop that is peeled completely.  */
> +DEFPARAM(PARAM_MAX_PEEL_BRANCHES,
> +	"max-completely-peel-times",
> +	"The maximum number of branches on the path through the peeled sequence",
> +	32, 0, 0)
>  /* The maximum depth of a loop nest we completely peel.  */
>  DEFPARAM(PARAM_MAX_UNROLL_ITERATIONS,
>  	 "max-completely-peel-loop-nest-depth",
> 
>