Re: [vec-cmp, patch 3/6] Vectorize comparison

[Richard Biener <richard dot guenther at gmail dot com>]

On Wed, Oct 14, 2015 at 6:12 PM, Ilya Enkovich <enkovich.gnu@gmail.com> wrote:
> On 14 Oct 15:06, Ilya Enkovich wrote:
>>
>> Will send an updated version after testing.
>>
>> Thanks,
>> Ilya
>>
>
> Here is an updated patch version.
>
> Thanks,
> Ilya
> --
> gcc/
>
> 2015-10-14  Ilya Enkovich  <enkovich.gnu@gmail.com>
>
>         * tree-vect-data-refs.c (vect_get_new_vect_var): Support vect_mask_var.
>         (vect_create_destination_var): Likewise.
>         * tree-vect-stmts.c (vectorizable_comparison): New.
>         (vect_analyze_stmt): Add vectorizable_comparison.
>         (vect_transform_stmt): Likewise.
>         * tree-vectorizer.h (enum vect_var_kind): Add vect_mask_var.
>         (enum stmt_vec_info_type): Add comparison_vec_info_type.
>         (vectorizable_comparison): New.
>
>
> diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c
> index 8a4d489..0be0523 100644
> --- a/gcc/tree-vect-data-refs.c
> +++ b/gcc/tree-vect-data-refs.c
> @@ -3870,6 +3870,9 @@ vect_get_new_vect_var (tree type, enum vect_var_kind var_kind, const char *name)
>    case vect_scalar_var:
>      prefix = "stmp";
>      break;
> +  case vect_mask_var:
> +    prefix = "mask";
> +    break;
>    case vect_pointer_var:
>      prefix = "vectp";
>      break;
> @@ -4424,7 +4427,11 @@ vect_create_destination_var (tree scalar_dest, tree vectype)
>    tree type;
>    enum vect_var_kind kind;
>
> -  kind = vectype ? vect_simple_var : vect_scalar_var;
> +  kind = vectype
> +    ? VECTOR_BOOLEAN_TYPE_P (vectype)
> +    ? vect_mask_var
> +    : vect_simple_var
> +    : vect_scalar_var;
>    type = vectype ? vectype : TREE_TYPE (scalar_dest);
>
>    gcc_assert (TREE_CODE (scalar_dest) == SSA_NAME);
> diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c
> index 23cec8a..6a52895 100644
> --- a/gcc/tree-vect-stmts.c
> +++ b/gcc/tree-vect-stmts.c
> @@ -7516,6 +7516,192 @@ vectorizable_condition (gimple *stmt, gimple_stmt_iterator *gsi,
>    return true;
>  }
>
> +/* vectorizable_comparison.
> +
> +   Check if STMT is comparison expression that can be vectorized.
> +   If VEC_STMT is also passed, vectorize the STMT: create a vectorized
> +   comparison, put it in VEC_STMT, and insert it at GSI.
> +
> +   Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
> +
> +bool
> +vectorizable_comparison (gimple *stmt, gimple_stmt_iterator *gsi,
> +                        gimple **vec_stmt, tree reduc_def,
> +                        slp_tree slp_node)
> +{
> +  tree lhs, rhs1, rhs2;
> +  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
> +  tree vectype1 = NULL_TREE, vectype2 = NULL_TREE;
> +  tree vectype = STMT_VINFO_VECTYPE (stmt_info);
> +  tree vec_rhs1 = NULL_TREE, vec_rhs2 = NULL_TREE;
> +  tree vec_compare;
> +  tree new_temp;
> +  loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
> +  tree def;
> +  enum vect_def_type dts[2] = {vect_unknown_def_type, vect_unknown_def_type};
> +  unsigned nunits;
> +  int ncopies;
> +  enum tree_code code;
> +  stmt_vec_info prev_stmt_info = NULL;
> +  int i, j;
> +  bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
> +  vec<tree> vec_oprnds0 = vNULL;
> +  vec<tree> vec_oprnds1 = vNULL;
> +  gimple *def_stmt;
> +  tree mask_type;
> +  tree mask;
> +
> +  if (!VECTOR_BOOLEAN_TYPE_P (vectype))
> +    return false;
> +
> +  mask_type = vectype;
> +  nunits = TYPE_VECTOR_SUBPARTS (vectype);
> +
> +  if (slp_node || PURE_SLP_STMT (stmt_info))
> +    ncopies = 1;
> +  else
> +    ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits;
> +
> +  gcc_assert (ncopies >= 1);
> +  if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
> +    return false;
> +
> +  if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_internal_def
> +      && !(STMT_VINFO_DEF_TYPE (stmt_info) == vect_nested_cycle
> +          && reduc_def))
> +    return false;
> +
> +  if (STMT_VINFO_LIVE_P (stmt_info))
> +    {
> +      if (dump_enabled_p ())
> +       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> +                        "value used after loop.\n");
> +      return false;
> +    }
> +
> +  if (!is_gimple_assign (stmt))
> +    return false;
> +
> +  code = gimple_assign_rhs_code (stmt);
> +
> +  if (TREE_CODE_CLASS (code) != tcc_comparison)
> +    return false;
> +
> +  rhs1 = gimple_assign_rhs1 (stmt);
> +  rhs2 = gimple_assign_rhs2 (stmt);
> +
> +  if (!vect_is_simple_use_1 (rhs1, stmt, stmt_info->vinfo,
> +                            &def_stmt, &def, &dts[0], &vectype1))
> +    return false;
> +
> +  if (!vect_is_simple_use_1 (rhs2, stmt, stmt_info->vinfo,
> +                            &def_stmt, &def, &dts[1], &vectype2))
> +       return false;
> +
> +  if (vectype1 && vectype2
> +      && TYPE_VECTOR_SUBPARTS (vectype1) != TYPE_VECTOR_SUBPARTS (vectype2))
> +    return false;
> +
> +  vectype = vectype1 ? vectype1 : vectype2;
> +
> +  /* Invariant comparison.  */
> +  if (!vectype)
> +    {
> +      vectype = build_vector_type (TREE_TYPE (rhs1), nunits);
> +      if (tree_to_shwi (TYPE_SIZE_UNIT (vectype)) != current_vector_size)
> +       return false;
> +    }
> +  else if (nunits != TYPE_VECTOR_SUBPARTS (vectype))
> +    return false;
> +
> +  if (!vec_stmt)
> +    {
> +      STMT_VINFO_TYPE (stmt_info) = comparison_vec_info_type;
> +      vect_model_simple_cost (stmt_info, ncopies, dts, NULL, NULL);
> +      return expand_vec_cmp_expr_p (vectype, mask_type);
> +    }
> +
> +  /* Transform.  */
> +  if (!slp_node)
> +    {
> +      vec_oprnds0.create (1);
> +      vec_oprnds1.create (1);
> +    }
> +
> +  /* Handle def.  */
> +  lhs = gimple_assign_lhs (stmt);
> +  mask = vect_create_destination_var (lhs, mask_type);
> +
> +  /* Handle cmp expr.  */
> +  for (j = 0; j < ncopies; j++)
> +    {
> +      gassign *new_stmt = NULL;
> +      if (j == 0)
> +       {
> +         if (slp_node)
> +           {
> +             auto_vec<tree, 2> ops;
> +             auto_vec<vec<tree>, 2> vec_defs;
> +
> +             ops.safe_push (rhs1);
> +             ops.safe_push (rhs2);
> +             vect_get_slp_defs (ops, slp_node, &vec_defs, -1);
> +             vec_oprnds1 = vec_defs.pop ();
> +             vec_oprnds0 = vec_defs.pop ();
> +
> +             ops.release ();
> +             vec_defs.release ();

No need to release auto_vec<>s at the end of scope explicitely.

> +           }
> +         else
> +           {
> +             vec_rhs1 = vect_get_vec_def_for_operand (rhs1, stmt, NULL);
> +             vec_rhs2 = vect_get_vec_def_for_operand (rhs2, stmt, NULL);
> +           }
> +       }
> +      else
> +       {
> +         vec_rhs1 = vect_get_vec_def_for_stmt_copy (dts[0],
> +                                                    vec_oprnds0.pop ());
> +         vec_rhs2 = vect_get_vec_def_for_stmt_copy (dts[1],
> +                                                    vec_oprnds1.pop ());
> +       }
> +
> +      if (!slp_node)
> +       {
> +         vec_oprnds0.quick_push (vec_rhs1);
> +         vec_oprnds1.quick_push (vec_rhs2);
> +       }
> +
> +      /* Arguments are ready.  Create the new vector stmt.  */
> +      FOR_EACH_VEC_ELT (vec_oprnds0, i, vec_rhs1)
> +       {
> +         vec_rhs2 = vec_oprnds1[i];
> +
> +         vec_compare = build2 (code, mask_type, vec_rhs1, vec_rhs2);
> +         new_stmt = gimple_build_assign (mask, vec_compare);
> +         new_temp = make_ssa_name (mask, new_stmt);
> +         gimple_assign_set_lhs (new_stmt, new_temp);

 new_temp = make_ssa_name (mask);
 gimple_build_assign (new_temp, code, vec_rhs1, vec_rhs2);

for the 4 stmts above.

> +         vect_finish_stmt_generation (stmt, new_stmt, gsi);
> +         if (slp_node)
> +           SLP_TREE_VEC_STMTS (slp_node).quick_push (new_stmt);
> +       }
> +
> +      if (slp_node)
> +       continue;
> +
> +      if (j == 0)
> +       STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_stmt;
> +      else
> +       STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt;
> +
> +      prev_stmt_info = vinfo_for_stmt (new_stmt);
> +    }
> +
> +  vec_oprnds0.release ();
> +  vec_oprnds1.release ();

Please use auto_vec<>s.

Ok with those changes.

RIchard.

> +
> +  return true;
> +}
>
>  /* Make sure the statement is vectorizable.  */
>
> @@ -7719,7 +7905,8 @@ vect_analyze_stmt (gimple *stmt, bool *need_to_vectorize, slp_tree node)
>           || vectorizable_call (stmt, NULL, NULL, node)
>           || vectorizable_store (stmt, NULL, NULL, node)
>           || vectorizable_reduction (stmt, NULL, NULL, node)
> -         || vectorizable_condition (stmt, NULL, NULL, NULL, 0, node));
> +         || vectorizable_condition (stmt, NULL, NULL, NULL, 0, node)
> +         || vectorizable_comparison (stmt, NULL, NULL, NULL, node));
>    else
>      {
>        if (bb_vinfo)
> @@ -7731,7 +7918,8 @@ vect_analyze_stmt (gimple *stmt, bool *need_to_vectorize, slp_tree node)
>               || vectorizable_load (stmt, NULL, NULL, node, NULL)
>               || vectorizable_call (stmt, NULL, NULL, node)
>               || vectorizable_store (stmt, NULL, NULL, node)
> -             || vectorizable_condition (stmt, NULL, NULL, NULL, 0, node));
> +             || vectorizable_condition (stmt, NULL, NULL, NULL, 0, node)
> +             || vectorizable_comparison (stmt, NULL, NULL, NULL, node));
>      }
>
>    if (!ok)
> @@ -7847,6 +8035,11 @@ vect_transform_stmt (gimple *stmt, gimple_stmt_iterator *gsi,
>        gcc_assert (done);
>        break;
>
> +    case comparison_vec_info_type:
> +      done = vectorizable_comparison (stmt, gsi, &vec_stmt, NULL, slp_node);
> +      gcc_assert (done);
> +      break;
> +
>      case call_vec_info_type:
>        done = vectorizable_call (stmt, gsi, &vec_stmt, slp_node);
>        stmt = gsi_stmt (*gsi);
> diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h
> index 5b766cf..f8d1e97 100644
> --- a/gcc/tree-vectorizer.h
> +++ b/gcc/tree-vectorizer.h
> @@ -28,7 +28,8 @@ along with GCC; see the file COPYING3.  If not see
>  enum vect_var_kind {
>    vect_simple_var,
>    vect_pointer_var,
> -  vect_scalar_var
> +  vect_scalar_var,
> +  vect_mask_var
>  };
>
>  /* Defines type of operation.  */
> @@ -441,6 +442,7 @@ enum stmt_vec_info_type {
>    call_simd_clone_vec_info_type,
>    assignment_vec_info_type,
>    condition_vec_info_type,
> +  comparison_vec_info_type,
>    reduc_vec_info_type,
>    induc_vec_info_type,
>    type_promotion_vec_info_type,
> @@ -1002,6 +1004,8 @@ extern void vect_remove_stores (gimple *);
>  extern bool vect_analyze_stmt (gimple *, bool *, slp_tree);
>  extern bool vectorizable_condition (gimple *, gimple_stmt_iterator *,
>                                     gimple **, tree, int, slp_tree);
> +extern bool vectorizable_comparison (gimple *, gimple_stmt_iterator *,
> +                                    gimple **, tree, int, slp_tree);
>  extern void vect_get_load_cost (struct data_reference *, int, bool,
>                                 unsigned int *, unsigned int *,
>                                 stmt_vector_for_cost *,