Re: [PATCH] vect: Remove vec_outside/inside_cost fields

[Richard Biener <richard.guenther@gmail.com>]

On Mon, Nov 8, 2021 at 11:44 AM Richard Sandiford via Gcc-patches
<gcc-patches@gcc.gnu.org> wrote:
>
> The vector costs now use a common base class instead of being
> completely abstract.  This means that there's no longer a
> need to record the inside and outside costs separately.
>
> Tested on aarch64-linux-gnu and x86_64-linux-gnu.  OK to install?

OK.

Richard.

> Richard
>
>
> gcc/
>         * tree-vectorizer.h (_loop_vec_info): Remove vec_outside_cost
>         and vec_inside_cost.
>         (vector_costs::outside_cost): New function.
>         * tree-vectorizer.c (_loop_vec_info::_loop_vec_info): Update
>         after above.
>         (vect_estimate_min_profitable_iters): Likewise.
>         (vect_better_loop_vinfo_p): Get the inside and outside costs
>         from the loop_vec_infos' vector_costs.
> ---
>  gcc/tree-vect-loop.c  | 24 ++++++++++--------------
>  gcc/tree-vectorizer.h | 16 +++++++++-------
>  2 files changed, 19 insertions(+), 21 deletions(-)
>
> diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c
> index b6a631d4384..dd4a363fee5 100644
> --- a/gcc/tree-vect-loop.c
> +++ b/gcc/tree-vect-loop.c
> @@ -840,8 +840,6 @@ _loop_vec_info::_loop_vec_info (class loop *loop_in, vec_info_shared *shared)
>      scan_map (NULL),
>      slp_unrolling_factor (1),
>      single_scalar_iteration_cost (0),
> -    vec_outside_cost (0),
> -    vec_inside_cost (0),
>      inner_loop_cost_factor (param_vect_inner_loop_cost_factor),
>      vectorizable (false),
>      can_use_partial_vectors_p (param_vect_partial_vector_usage != 0),
> @@ -2845,10 +2843,10 @@ vect_better_loop_vinfo_p (loop_vec_info new_loop_vinfo,
>        /* Compute the costs by multiplying the inside costs with the factor and
>          add the outside costs for a more complete picture.  The factor is the
>          amount of times we are expecting to iterate this epilogue.  */
> -      old_cost = old_loop_vinfo->vec_inside_cost * old_factor;
> -      new_cost = new_loop_vinfo->vec_inside_cost * new_factor;
> -      old_cost += old_loop_vinfo->vec_outside_cost;
> -      new_cost += new_loop_vinfo->vec_outside_cost;
> +      old_cost = old_loop_vinfo->vector_costs->body_cost () * old_factor;
> +      new_cost = new_loop_vinfo->vector_costs->body_cost () * new_factor;
> +      old_cost += old_loop_vinfo->vector_costs->outside_cost ();
> +      new_cost += new_loop_vinfo->vector_costs->outside_cost ();
>        return new_cost < old_cost;
>      }
>
> @@ -2865,8 +2863,8 @@ vect_better_loop_vinfo_p (loop_vec_info new_loop_vinfo,
>
>    /* Check whether the (fractional) cost per scalar iteration is lower
>       or higher: new_inside_cost / new_vf vs. old_inside_cost / old_vf.  */
> -  poly_int64 rel_new = new_loop_vinfo->vec_inside_cost * old_vf;
> -  poly_int64 rel_old = old_loop_vinfo->vec_inside_cost * new_vf;
> +  poly_int64 rel_new = new_loop_vinfo->vector_costs->body_cost () * old_vf;
> +  poly_int64 rel_old = old_loop_vinfo->vector_costs->body_cost () * new_vf;
>
>    HOST_WIDE_INT est_rel_new_min
>      = estimated_poly_value (rel_new, POLY_VALUE_MIN);
> @@ -2918,8 +2916,10 @@ vect_better_loop_vinfo_p (loop_vec_info new_loop_vinfo,
>
>    /* If there's nothing to choose between the loop bodies, see whether
>       there's a difference in the prologue and epilogue costs.  */
> -  if (new_loop_vinfo->vec_outside_cost != old_loop_vinfo->vec_outside_cost)
> -    return new_loop_vinfo->vec_outside_cost < old_loop_vinfo->vec_outside_cost;
> +  auto old_outside_cost = old_loop_vinfo->vector_costs->outside_cost ();
> +  auto new_outside_cost = new_loop_vinfo->vector_costs->outside_cost ();
> +  if (new_outside_cost != old_outside_cost)
> +    return new_outside_cost < old_outside_cost;
>
>    return false;
>  }
> @@ -4272,10 +4272,6 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo,
>
>    vec_outside_cost = (int)(vec_prologue_cost + vec_epilogue_cost);
>
> -  /* Stash the costs so that we can compare two loop_vec_infos.  */
> -  loop_vinfo->vec_inside_cost = vec_inside_cost;
> -  loop_vinfo->vec_outside_cost = vec_outside_cost;
> -
>    if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "Cost model analysis: \n");
> diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h
> index 1cd6cc036f2..87d3f211a2e 100644
> --- a/gcc/tree-vectorizer.h
> +++ b/gcc/tree-vectorizer.h
> @@ -724,13 +724,6 @@ public:
>    /* Cost of a single scalar iteration.  */
>    int single_scalar_iteration_cost;
>
> -  /* The cost of the vector prologue and epilogue, including peeled
> -     iterations and set-up code.  */
> -  int vec_outside_cost;
> -
> -  /* The cost of the vector loop body.  */
> -  int vec_inside_cost;
> -
>    /* The factor used to over weight those statements in an inner loop
>       relative to the loop being vectorized.  */
>    unsigned int inner_loop_cost_factor;
> @@ -1429,6 +1422,7 @@ public:
>    unsigned int prologue_cost () const;
>    unsigned int body_cost () const;
>    unsigned int epilogue_cost () const;
> +  unsigned int outside_cost () const;
>
>  protected:
>    unsigned int record_stmt_cost (stmt_vec_info, vect_cost_model_location,
> @@ -1489,6 +1483,14 @@ vector_costs::epilogue_cost () const
>    return m_costs[vect_epilogue];
>  }
>
> +/* Return the cost of the prologue and epilogue code (in abstract units).  */
> +
> +inline unsigned int
> +vector_costs::outside_cost () const
> +{
> +  return prologue_cost () + epilogue_cost ();
> +}
> +
>  #define VECT_MAX_COST 1000
>
>  /* The maximum number of intermediate steps required in multi-step type
> --
> 2.25.1
>