On Thu, 5 Nov 2026 03:41:18 +0800 Max Chou <[email protected]> wrote:
> The RISC-V Bulk Normalization Algorithm (RVBNA) is a scheme employed by > multiple RISC-V extensions (e.g. Zvdota/Zvbdota family) for efficient > computation of floating-point dot products. > > Signed-off-by: Max Chou <[email protected]> > --- > MAINTAINERS | 6 + > target/riscv/tcg/meson.build | 2 +- > target/riscv/tcg/rvbna.c | 185 +++++++++++++++++++++++++++++++ > target/riscv/tcg/rvbna.h | 40 +++++++ > target/riscv/tcg/vector_helper.c | 1 + > 5 files changed, 233 insertions(+), 1 deletion(-) > create mode 100644 target/riscv/tcg/rvbna.c > create mode 100644 target/riscv/tcg/rvbna.h > > diff --git a/MAINTAINERS b/MAINTAINERS > index 55463103ff1..b91e5925344 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -416,6 +416,12 @@ F: target/riscv/tcg/xsf_helper.c > F: disas/riscv-xsf* > F: tests/tcg/riscv64/test-xsfvqmacc.S > > +RISC-V Bulk Normalization Algorithm (RVBNA) > +M: Max Chou <[email protected]> > +L: [email protected] > +S: Supported > +F: target/riscv/tcg/rvbna.* > + > RENESAS RX CPUs > R: Yoshinori Sato <[email protected]> > S: Orphan > diff --git a/target/riscv/tcg/meson.build b/target/riscv/tcg/meson.build > index 86805b30cbc..3b7821178fc 100644 > --- a/target/riscv/tcg/meson.build > +++ b/target/riscv/tcg/meson.build > @@ -10,6 +10,7 @@ riscv_ss.add(files( > 'fpu_helper.c', > 'm128_helper.c', > 'op_helper.c', > + 'rvbna.c', > 'translate.c', > 'tcg-cpu.c', > 'vcrypto_helper.c', > @@ -27,4 +28,3 @@ riscv_system_ss.add(files( > 'th_csr.c', > )) > > - > diff --git a/target/riscv/tcg/rvbna.c b/target/riscv/tcg/rvbna.c > new file mode 100644 > index 00000000000..f6150e4976d > --- /dev/null > +++ b/target/riscv/tcg/rvbna.c > @@ -0,0 +1,185 @@ > +/* > + * RISC-V Bulk Normalization Algorithm (RVBNA) > + * > + * Copyright (c) 2026 SiFive, Inc. > + * > + * SPDX-License-Identifier: GPL-2.0-or-later > + */ > + > +#include "qemu/osdep.h" > +#include "qemu/bitops.h" > +#include "qemu/host-utils.h" > +#include "fpu/softfloat.h" > +#include "fpu/softfloat-macros.h" > +#include "rvbna.h" > + > +static inline int rvbna_guard_bits(uint32_t n_prod) > +{ > + g_assert(n_prod > 0); > + return 32 - clz32(n_prod - 1); > +} > + > +float32 rvbna_final_f32_add(float32 partial, float32 accumulator, > + float_status *fp_status) > +{ > + FloatRoundMode old_rm = get_float_rounding_mode(fp_status); > + int old_flags = get_float_exception_flags(fp_status); > + int new_flags; > + float32 result; > + > + set_float_rounding_mode(float_round_to_odd_inf, fp_status); > + set_float_exception_flags(0, fp_status); Why are we adding this exception flag clear operation? > + result = float32_add(partial, accumulator, fp_status); > + new_flags = get_float_exception_flags(fp_status) & > + (float_flag_invalid | float_flag_overflow); We can simplify the variable definitions. Using a 'flags' instead of 'old_flags' and 'new_flags' is enough. Otherwise, looks good to me. Reviewed-by: Chao Liu <[email protected]> Thanks, Chao > + set_float_rounding_mode(old_rm, fp_status); > + set_float_exception_flags(old_flags | new_flags, fp_status); > + > + return result; > +} > + > +#define RVBNA_STACK_THRESHOLD 8 > + > +#define GEN_RVBNA(TA, TB, TO, A_E, A_M, B_E, B_M, OUT_E, OUT_M) > \ > +TO rvbna_dot_##TA##_##TB(const TA a[], const TB b[], uint32_t n_prod, > \ > + float_status *fp_status) > \ > +{ > \ > + int32_t stack_ref_exps[RVBNA_STACK_THRESHOLD]; > \ > + bool stack_signs[RVBNA_STACK_THRESHOLD]; > \ > + uint64_t stack_sigs[RVBNA_STACK_THRESHOLD]; > \ > + int32_t *prod_ref_exps = stack_ref_exps; > \ > + bool *prod_signs = stack_signs; > \ > + uint64_t *prod_sigs = stack_sigs; > \ > + g_autofree int32_t *heap_ref_exps = NULL; > \ > + g_autofree bool *heap_signs = NULL; > \ > + g_autofree uint64_t *heap_sigs = NULL; > \ > + int guard_bits = rvbna_guard_bits(n_prod); > \ > + int pad = OUT_M - (A_M + B_M) + guard_bits; > \ > + int output_bias = (1 << (OUT_E - 1)) - 1; > \ > + int a_exp_bias = (1 << (A_E - 1)) - 1; > \ > + int b_exp_bias = (1 << (B_E - 1)) - 1; > \ > + int ref_bias = output_bias - (a_exp_bias + b_exp_bias); > \ > + int max_prod_ref_exp = ref_bias; > \ > + int overflow_exp = (1 << OUT_E) - 1; > \ > + int64_t acc = 0; > \ > + bool nan_result = false; > \ > + bool inf_result = false; > \ > + bool inf_sign = false; > \ > + bool any_pos_inf = false; > \ > + bool any_neg_inf = false; > \ > + bool any_invalid_prod = false; > \ > + bool any_signan = false; > \ > + bool op_sign_inf, sign, overflow; > \ > + uint32_t i; > \ > + uint64_t sig; > \ > + int lead, exp, sig_bits; > \ > + > \ > + g_assert(pad >= 0); > \ > + if (n_prod > RVBNA_STACK_THRESHOLD) { > \ > + heap_ref_exps = g_new(int32_t, n_prod); > \ > + heap_signs = g_new(bool, n_prod); > \ > + heap_sigs = g_new(uint64_t, n_prod); > \ > + prod_ref_exps = heap_ref_exps; > \ > + prod_signs = heap_signs; > \ > + prod_sigs = heap_sigs; > \ > + } > \ > + > \ > + for (i = 0; i < n_prod; i++) { > \ > + bool a_sign = TA##_is_neg(a[i]); > \ > + bool b_sign = TB##_is_neg(b[i]); > \ > + bool a_sub = TA##_is_zero_or_denormal(a[i]); > \ > + bool b_sub = TB##_is_zero_or_denormal(b[i]); > \ > + bool a_zero = TA##_is_zero(a[i]); > \ > + bool b_zero = TB##_is_zero(b[i]); > \ > + bool a_inf = TA##_is_infinity(a[i]); > \ > + bool b_inf = TB##_is_infinity(b[i]); > \ > + bool a_nan = TA##_is_any_nan(a[i]); > \ > + bool b_nan = TB##_is_any_nan(b[i]); > \ > + bool prod_sign = a_sign ^ b_sign; > \ > + bool invalid_prod = (a_inf && b_zero) || (b_inf && a_zero); > \ > + bool inf_prod_lhs = a_inf && !b_nan && !b_zero; > \ > + bool inf_prod_rhs = b_inf && !a_nan && !a_zero; > \ > + bool inf_prod = inf_prod_lhs || inf_prod_rhs; > \ > + bool invalid_sum = inf_result && inf_prod && > \ > + (inf_sign != prod_sign); > \ > + uint32_t a_mant = extract32(a[i], 0, A_M); > \ > + uint32_t b_mant = extract32(b[i], 0, B_M); > \ > + bool a_signan = a_nan && TA##_is_signaling_nan(a[i], fp_status); > \ > + bool b_signan = b_nan && TB##_is_signaling_nan(b[i], fp_status); > \ > + uint64_t a_sig = a_mant | (!a_sub << A_M); > \ > + uint64_t b_sig = b_mant | (!b_sub << B_M); > \ > + bool prod_is_zero = a_zero || b_zero; > \ > + bool either_inf = a_inf || b_inf; > \ > + bool either_nan = a_nan || b_nan; > \ > + > \ > + any_invalid_prod |= invalid_prod; > \ > + nan_result |= a_nan || b_nan || any_invalid_prod || invalid_sum; > \ > + inf_result |= inf_prod; > \ > + inf_sign = inf_prod ? prod_sign : inf_sign; > \ > + > \ > + prod_signs[i] = prod_sign; > \ > + prod_sigs[i] = (uint64_t)(a_sig * b_sig) << pad; > \ > + prod_ref_exps[i] = ref_bias; > \ > + if (!prod_is_zero) { > \ > + prod_ref_exps[i] += (a_sub ? 1 : extract32(a[i], A_M, A_E)) + > \ > + (b_sub ? 1 : extract32(b[i], B_M, B_E)); > \ > + } > \ > + max_prod_ref_exp = MAX(prod_ref_exps[i], max_prod_ref_exp); > \ > + > \ > + any_pos_inf |= (either_inf && !either_nan && !prod_is_zero && > \ > + (a_sign == b_sign)); > \ > + any_neg_inf |= (either_inf && !either_nan && !prod_is_zero && > \ > + (a_sign != b_sign)); > \ > + any_signan |= a_signan || b_signan; > \ > + } > \ > + > \ > + op_sign_inf = any_pos_inf && any_neg_inf; > \ > + > \ > + if (nan_result) { > \ > + if (any_signan || any_invalid_prod || op_sign_inf) { > \ > + float_raise(float_flag_invalid, fp_status); > \ > + } > \ > + return TO##_default_nan(fp_status); > \ > + } else if (inf_result) { > \ > + return TO##_set_sign(TO##_infinity, inf_sign); > \ > + } > \ > + > \ > + for (i = 0; i < n_prod; i++) { > \ > + shift64RightJamming(prod_sigs[i], > \ > + max_prod_ref_exp - prod_ref_exps[i], &sig); > \ > + acc += prod_signs[i] ? -(int64_t)sig : (int64_t)sig; > \ > + } > \ > + > \ > + sign = acc < 0; > \ > + sig = sign ? -(uint64_t)acc : acc; > \ > + if (sig == 0) { > \ > + return 0; > \ > + } > \ > + > \ > + lead = 63 - clz64(sig); > \ > + exp = max_prod_ref_exp - OUT_M - guard_bits + lead; > \ > + overflow = exp >= overflow_exp; > \ > + if (overflow) { > \ > + float_raise(float_flag_overflow, fp_status); > \ > + sig = 0; > \ > + exp = overflow_exp; > \ > + } else { > \ > + sig_bits = MAX(0, exp <= 0 ? OUT_M - (1 - exp) : OUT_M); > \ > + if (lead > sig_bits) { > \ > + shift64RightJamming(sig, lead - sig_bits, &sig); > \ > + } else { > \ > + sig <<= (sig_bits - lead); > \ > + } > \ > + exp = MAX(exp, 0); > \ > + } > \ > + return (TO)deposit64(deposit64(sig, OUT_M, OUT_E, exp), > \ > + OUT_M + OUT_E, > \ > + 1, sign); > \ > +} > + > +GEN_RVBNA(float8_e4m3, float8_e4m3, float32, 4, 3, 4, 3, 8, 23) > +GEN_RVBNA(float8_e4m3, float8_e5m2, float32, 4, 3, 5, 2, 8, 23) > +GEN_RVBNA(float8_e5m2, float8_e4m3, float32, 5, 2, 4, 3, 8, 23) > +GEN_RVBNA(float8_e5m2, float8_e5m2, float32, 5, 2, 5, 2, 8, 23) > +GEN_RVBNA(float16, float16, float32, 5, 10, 5, 10, 8, 23) > +GEN_RVBNA(bfloat16, bfloat16, float32, 8, 7, 8, 7, 8, 23) > diff --git a/target/riscv/tcg/rvbna.h b/target/riscv/tcg/rvbna.h > new file mode 100644 > index 00000000000..d4d3eced952 > --- /dev/null > +++ b/target/riscv/tcg/rvbna.h > @@ -0,0 +1,40 @@ > +/* > + * RISC-V Bulk Normalization Algorithm (RVBNA) > + * > + * Copyright (c) 2026 SiFive, Inc. > + * > + * SPDX-License-Identifier: GPL-2.0-or-later > + */ > + > +#ifndef TARGET_RISCV_TCG_RVBNA_H > +#define TARGET_RISCV_TCG_RVBNA_H > + > +#include "fpu/softfloat.h" > + > +float32 rvbna_final_f32_add(float32 partial, float32 accumulator, > + float_status *fp_status); > + > +float32 rvbna_dot_float8_e4m3_float8_e4m3(const float8_e4m3 a[], > + const float8_e4m3 b[], > + uint32_t n_prod, > + float_status *fp_status); > +float32 rvbna_dot_float8_e4m3_float8_e5m2(const float8_e4m3 a[], > + const float8_e5m2 b[], > + uint32_t n_prod, > + float_status *fp_status); > +float32 rvbna_dot_float8_e5m2_float8_e4m3(const float8_e5m2 a[], > + const float8_e4m3 b[], > + uint32_t n_prod, > + float_status *fp_status); > +float32 rvbna_dot_float8_e5m2_float8_e5m2(const float8_e5m2 a[], > + const float8_e5m2 b[], > + uint32_t n_prod, > + float_status *fp_status); > +float32 rvbna_dot_float16_float16(const float16 a[], const float16 b[], > + uint32_t n_prod, > + float_status *fp_status); > +float32 rvbna_dot_bfloat16_bfloat16(const bfloat16 a[], const bfloat16 b[], > + uint32_t n_prod, > + float_status *fp_status); > + > +#endif > diff --git a/target/riscv/tcg/vector_helper.c > b/target/riscv/tcg/vector_helper.c > index 917a48b5106..172ae0f11dc 100644 > --- a/target/riscv/tcg/vector_helper.c > +++ b/target/riscv/tcg/vector_helper.c > @@ -31,6 +31,7 @@ > #include "tcg/tcg-gvec-desc.h" > #include "internals.h" > #include "vector_internals.h" > +#include "rvbna.h" > #include <math.h> > > static target_ulong vtype_reserved(CPURISCVState *env, target_ulong vtype) > -- > 2.56.0 > > > Sent using hkml (https://github.com/sjp38/hackermail)
