This patch fixes PR11153: ble a1,zero,.L8 addiw a5,a1,-1 li a4,4 addi sp,sp,-16 mv a2,a0 sext.w a3,a1 bleu a5,a4,.L9 srliw a4,a3,2 slli a4,a4,4 mv a5,a0 add a4,a4,a0 vsetivli zero,4,e32,m1,ta,ma vmv.v.i v1,0 vse32.v v1,0(sp) .L4: vle32.v v1,0(a5) ---> This loop always processes 4 elements which is ok for VLEN = 128bits, but waste a huge amount of computation units when VLEN > 128bits vle32.v v2,0(sp) addi a5,a5,16 vadd.vv v1,v2,v1 vse32.v v1,0(sp) bne a4,a5,.L4 ld a5,0(sp) lw a4,0(sp) andi a1,a1,-4 srai a5,a5,32 addw a5,a4,a5 lw a4,8(sp) addw a5,a5,a4 ld a4,8(sp) srai a4,a4,32 addw a0,a5,a4 beq a3,a1,.L15 .L3: subw a3,a3,a1 slli a5,a1,32 slli a3,a3,32 srli a3,a3,32 srli a5,a5,30 add a2,a2,a5 vsetvli a5,a3,e8,mf4,tu,mu vsetvli a4,zero,e32,m1,ta,ma sub a1,a3,a5 vmv.v.i v1,0 vsetvli zero,a3,e32,m1,tu,ma vle32.v v2,0(a2) vmv.v.v v1,v2 bne a3,a5,.L21 .L7: vsetvli a4,zero,e32,m1,ta,ma vmv.s.x v2,zero vredsum.vs v1,v1,v2 vmv.x.s a5,v1 addw a0,a0,a5 .L15: addi sp,sp,16 jr ra .L21: slli a5,a5,2 add a2,a2,a5 vsetvli zero,a1,e32,m1,tu,ma vle32.v v2,0(a2) vadd.vv v1,v1,v2 j .L7 .L8: li a0,0 ret .L9: li a1,0 li a0,0 j .L3
The rootcause of this is we missed RVV builtin vectorization cost model. After this patch: ble a1,zero,.L4 vsetvli a5,zero,e32,m1,ta,ma vmv.v.i v1,0 .L3: vsetvli a5,a1,e32,m1,tu,ma vle32.v v2,0(a0) slli a4,a5,2 sub a1,a1,a5 add a0,a0,a4 vadd.vv v1,v2,v1 bne a1,zero,.L3 li a5,0 vsetivli zero,1,e32,m1,ta,ma vmv.s.x v2,a5 vsetvli a5,zero,e32,m1,ta,ma vredsum.vs v1,v1,v2 vmv.x.s a0,v1 ret .L4: li a0,0 ret PR target/111153 gcc/ChangeLog: * config/riscv/riscv-protos.h (struct common_vector_cost): New struct. (struct scalable_vector_cost): Ditto. (struct cpu_vector_cost): Ditto. * config/riscv/riscv-vector-costs.cc (costs::add_stmt_cost): Add RVV builtin vectorization cost * config/riscv/riscv.cc (struct riscv_tune_param): Ditto. (get_common_costs): New function. (riscv_builtin_vectorization_cost): Ditto. (TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST): New targethook. gcc/testsuite/ChangeLog: * gcc.dg/vect/costmodel/riscv/rvv/pr111153.c: New test. --- gcc/config/riscv/riscv-protos.h | 76 ++++++++++ gcc/config/riscv/riscv-vector-costs.cc | 5 +- gcc/config/riscv/riscv.cc | 143 ++++++++++++++++++ .../vect/costmodel/riscv/rvv/pr111153.c | 18 +++ 4 files changed, 239 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr111153.c diff --git a/gcc/config/riscv/riscv-protos.h b/gcc/config/riscv/riscv-protos.h index 85ab1db2088..7de0b031001 100644 --- a/gcc/config/riscv/riscv-protos.h +++ b/gcc/config/riscv/riscv-protos.h @@ -200,6 +200,82 @@ struct riscv_cpu_info { extern const riscv_cpu_info *riscv_find_cpu (const char *); +/* Common vector costs in any kind of vectorization (e.g VLA and VLS). */ +struct common_vector_cost +{ + /* Cost of any integer vector operation, excluding the ones handled + specially below. */ + const int int_stmt_cost; + + /* Cost of any fp vector operation, excluding the ones handled + specially below. */ + const int fp_stmt_cost; + + /* Gather/scatter vectorization cost. */ + const int gather_load_cost; + const int scatter_store_cost; + + /* Cost of a vector-to-scalar operation. */ + const int vec_to_scalar_cost; + + /* Cost of a scalar-to-vector operation. */ + const int scalar_to_vec_cost; + + /* Cost of a permute operation. */ + const int permute_cost; + + /* Cost of an aligned vector load. */ + const int align_load_cost; + + /* Cost of an aligned vector store. */ + const int align_store_cost; + + /* Cost of an unaligned vector load. */ + const int unalign_load_cost; + + /* Cost of an unaligned vector store. */ + const int unalign_store_cost; +}; + +/* scalable vectorization (VLA) specific cost. */ +struct scalable_vector_cost : common_vector_cost +{ + CONSTEXPR scalable_vector_cost (const common_vector_cost &base) + : common_vector_cost (base) + {} + + /* TODO: We will need more other kinds of vector cost for VLA. + E.g. fold_left reduction cost, lanes load/store cost, ..., etc. */ +}; + +/* Cost for vector insn classes. */ +struct cpu_vector_cost +{ + /* Cost of any integer scalar operation, excluding load and store. */ + const int scalar_int_stmt_cost; + + /* Cost of any fp scalar operation, excluding load and store. */ + const int scalar_fp_stmt_cost; + + /* Cost of a scalar load. */ + const int scalar_load_cost; + + /* Cost of a scalar store. */ + const int scalar_store_cost; + + /* Cost of a taken branch. */ + const int cond_taken_branch_cost; + + /* Cost of a not-taken branch. */ + const int cond_not_taken_branch_cost; + + /* Cost of an VLS modes operations. */ + const common_vector_cost *vls; + + /* Cost of an VLA modes operations. */ + const scalable_vector_cost *vla; +}; + /* Routines implemented in riscv-selftests.cc. */ #if CHECKING_P namespace selftest { diff --git a/gcc/config/riscv/riscv-vector-costs.cc b/gcc/config/riscv/riscv-vector-costs.cc index 7888cef58fe..e7bc9ed5233 100644 --- a/gcc/config/riscv/riscv-vector-costs.cc +++ b/gcc/config/riscv/riscv-vector-costs.cc @@ -750,9 +750,8 @@ costs::add_stmt_cost (int count, vect_cost_for_stmt kind, stmt_vec_info stmt_info, slp_tree, tree vectype, int misalign, vect_cost_model_location where) { - /* TODO: Use default STMT cost model. - We will support more accurate STMT cost model later. */ - int stmt_cost = default_builtin_vectorization_cost (kind, vectype, misalign); + int stmt_cost + = targetm.vectorize.builtin_vectorization_cost (kind, vectype, misalign); /* Do one-time initialization based on the vinfo. */ loop_vec_info loop_vinfo = dyn_cast<loop_vec_info> (m_vinfo); diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index 69a8a503f30..2dc44244309 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -281,6 +281,7 @@ struct riscv_tune_param bool slow_unaligned_access; bool use_divmod_expansion; unsigned int fusible_ops; + const struct cpu_vector_cost *vec_costs; }; @@ -348,6 +349,50 @@ const enum reg_class riscv_regno_to_class[FIRST_PSEUDO_REGISTER] = { VD_REGS, VD_REGS, VD_REGS, VD_REGS, }; +/* Generic costs for VLS vector operations. */ +static const common_vector_cost generic_vls_vector_cost = { + 1, /* int_stmt_cost */ + 1, /* fp_stmt_cost */ + 1, /* gather_load_cost */ + 1, /* scatter_store_cost */ + 1, /* vec_to_scalar_cost */ + 1, /* scalar_to_vec_cost */ + 1, /* permute_cost */ + 3, /* align_load_cost */ + 3, /* align_store_cost */ + 3, /* unalign_load_cost */ + 3, /* unalign_store_cost */ +}; + +/* Generic costs for VLA vector operations. */ +static const scalable_vector_cost generic_vla_vector_cost = { + { + 1, /* int_stmt_cost */ + 1, /* fp_stmt_cost */ + 1, /* gather_load_cost */ + 1, /* scatter_store_cost */ + 1, /* vec_to_scalar_cost */ + 1, /* scalar_to_vec_cost */ + 1, /* permute_cost */ + 3, /* align_load_cost */ + 3, /* align_store_cost */ + 3, /* unalign_load_cost */ + 3, /* unalign_store_cost */ + }, +}; + +/* Generic costs for vector insn classes. */ +static const struct cpu_vector_cost generic_vector_cost = { + 1, /* scalar_int_stmt_cost */ + 1, /* scalar_fp_stmt_cost */ + 1, /* scalar_load_cost */ + 1, /* scalar_store_cost */ + 3, /* cond_taken_branch_cost */ + 1, /* cond_not_taken_branch_cost */ + &generic_vls_vector_cost, /* vls */ + &generic_vla_vector_cost, /* vla */ +}; + /* Costs to use when optimizing for rocket. */ static const struct riscv_tune_param rocket_tune_info = { {COSTS_N_INSNS (4), COSTS_N_INSNS (5)}, /* fp_add */ @@ -362,6 +407,7 @@ static const struct riscv_tune_param rocket_tune_info = { true, /* slow_unaligned_access */ false, /* use_divmod_expansion */ RISCV_FUSE_NOTHING, /* fusible_ops */ + NULL, /* vector cost */ }; /* Costs to use when optimizing for Sifive 7 Series. */ @@ -378,6 +424,7 @@ static const struct riscv_tune_param sifive_7_tune_info = { true, /* slow_unaligned_access */ false, /* use_divmod_expansion */ RISCV_FUSE_NOTHING, /* fusible_ops */ + NULL, /* vector cost */ }; /* Costs to use when optimizing for T-HEAD c906. */ @@ -394,6 +441,7 @@ static const struct riscv_tune_param thead_c906_tune_info = { false, /* slow_unaligned_access */ false, /* use_divmod_expansion */ RISCV_FUSE_NOTHING, /* fusible_ops */ + NULL, /* vector cost */ }; /* Costs to use when optimizing for a generic ooo profile. */ @@ -410,6 +458,7 @@ static const struct riscv_tune_param generic_ooo_tune_info = { false, /* slow_unaligned_access */ false, /* use_divmod_expansion */ RISCV_FUSE_NOTHING, /* fusible_ops */ + &generic_vector_cost, /* vector cost */ }; /* Costs to use when optimizing for size. */ @@ -426,6 +475,7 @@ static const struct riscv_tune_param optimize_size_tune_info = { false, /* slow_unaligned_access */ false, /* use_divmod_expansion */ RISCV_FUSE_NOTHING, /* fusible_ops */ + NULL, /* vector cost */ }; static bool riscv_avoid_shrink_wrapping_separate (); @@ -10192,6 +10242,95 @@ riscv_frame_pointer_required (void) return riscv_save_frame_pointer && !crtl->is_leaf; } +/* Return the appropriate common costs for vectors of type VECTYPE. */ +static const common_vector_cost * +get_common_costs (tree vectype) +{ + const cpu_vector_cost *costs = tune_param->vec_costs; + gcc_assert (costs); + + if (vectype && riscv_v_ext_vls_mode_p (TYPE_MODE (vectype))) + return costs->vls; + return costs->vla; +} + +/* Implement targetm.vectorize.builtin_vectorization_cost. */ + +static int +riscv_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost, + tree vectype, int misalign ATTRIBUTE_UNUSED) +{ + unsigned elements; + const cpu_vector_cost *costs = tune_param->vec_costs; + bool fp = false; + + if (vectype != NULL) + fp = FLOAT_TYPE_P (vectype); + + if (costs != NULL) + { + const common_vector_cost *common_costs = get_common_costs (vectype); + gcc_assert (common_costs != NULL); + switch (type_of_cost) + { + case scalar_stmt: + return fp ? costs->scalar_fp_stmt_cost : costs->scalar_int_stmt_cost; + + case scalar_load: + return costs->scalar_load_cost; + + case scalar_store: + return costs->scalar_store_cost; + + case vector_stmt: + return fp ? common_costs->fp_stmt_cost : common_costs->int_stmt_cost; + + case vector_load: + return common_costs->align_load_cost; + + case vector_store: + return common_costs->align_store_cost; + + case vec_to_scalar: + return common_costs->vec_to_scalar_cost; + + case scalar_to_vec: + return common_costs->scalar_to_vec_cost; + + case unaligned_load: + return common_costs->unalign_load_cost; + case vector_gather_load: + return common_costs->gather_load_cost; + + case unaligned_store: + return common_costs->unalign_store_cost; + case vector_scatter_store: + return common_costs->scatter_store_cost; + + case cond_branch_taken: + return costs->cond_taken_branch_cost; + + case cond_branch_not_taken: + return costs->cond_not_taken_branch_cost; + + case vec_perm: + return common_costs->permute_cost; + + case vec_promote_demote: + return fp ? common_costs->fp_stmt_cost : common_costs->int_stmt_cost; + + case vec_construct: + elements = estimated_poly_value (TYPE_VECTOR_SUBPARTS (vectype)); + return elements / 2 + 1; + + default: + gcc_unreachable (); + } + } + + return default_builtin_vectorization_cost (type_of_cost, vectype, misalign); +} + /* Implement targetm.vectorize.create_costs. */ static vector_costs * @@ -10582,6 +10721,10 @@ extract_base_offset_in_addr (rtx mem, rtx *base, rtx *offset) #undef TARGET_FRAME_POINTER_REQUIRED #define TARGET_FRAME_POINTER_REQUIRED riscv_frame_pointer_required +#undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST +#define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST \ + riscv_builtin_vectorization_cost + #undef TARGET_VECTORIZE_CREATE_COSTS #define TARGET_VECTORIZE_CREATE_COSTS riscv_vectorize_create_costs diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr111153.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr111153.c new file mode 100644 index 00000000000..06e08ec5f2e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr111153.c @@ -0,0 +1,18 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -ftree-vectorize -mtune=generic-ooo" } */ + +#define DEF_REDUC_PLUS(TYPE) \ + TYPE __attribute__ ((noinline, noclone)) \ + reduc_plus_##TYPE (TYPE *__restrict a, int n) \ + { \ + TYPE r = 0; \ + for (int i = 0; i < n; ++i) \ + r += a[i]; \ + return r; \ + } + +#define TEST_PLUS(T) T (int) + +TEST_PLUS (DEF_REDUC_PLUS) + +/* { dg-final { scan-assembler-not {vsetivli\s+zero,\s*4} } } */ -- 2.36.3