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)

Reply via email to