fix convert bit-exactness

Author: AhmedHussein535

lib/src/bricks/impl/mli_prv_quant_vdsp.h

@@ -580,11 +580,7 @@ MLI_FORCE_INLINE vNx4int_t ir_rnn_result_requantize(
     vNx4int_t shift_left = mli_math_max_fx(-total_shift, 0);
     vNx4int_t shift_right = mli_math_min_fx(mli_math_max_fx(total_shift, 0), max_int_shift);
 
-    vNx4int_t preshift = mli_math_max_fx(shift_right - max_int_shift, 0);
-    shift_right = shift_right - preshift;
-
-    vNx4int_t acc_shifted = mli_math_asr_fx(acc_scaled, preshift);
-    acc_shifted = mli_math_asr_rnd_fx(acc_shifted, shift_right);
+    vNx4int_t acc_shifted = mli_math_asr_rnd_fx(acc_scaled, shift_right);
     acc_shifted = mli_math_asl_fx(acc_shifted, shift_left);
     return acc_shifted;
 }

lib/src/helpers/src/impl/mli_hlp_convert_tensor_ref.h

@@ -15,6 +15,37 @@
 #include "mli_prv_quant.h"
 #include "mli_prv_tensor.h"
 #include "mli_types.h"
+#include <math.h>
+
+template <typename in_T, typename out_T, typename acc_T>
+MLI_FORCE_INLINE void calc_convert(const MLI_PTR(in_T) src_tensor_arr,
+                                   MLI_OUT_PTR(out_T) dst_tensor_arr,
+                                   const int16_t in_zp, const int16_t scale,
+                                   const int16_t scale_shift, const int16_t out_zp) {
+    if (std::is_same<acc_T, int64_t>::value) {
+        const int mul_hi_shift = 32;
+        int32_t src_in_zp = mli_math_sub_fx<int32_t>(*src_tensor_arr, in_zp);
+        int32_t src_norm = mli_math_norm_fx<int32_t, int32_t>(src_in_zp);
+        src_in_zp = mli_math_asl_fx<int32_t>(src_in_zp, src_norm);
+
+        int32_t scale_norm = mli_math_norm_fx<int32_t, int32_t>((int32_t) scale);
+        int32_t scale32 = mli_math_asl_fx<int32_t>((int32_t) scale, scale_norm);
+
+        int64_t dst_acc = mli_math_mul_fx<int32_t, int64_t>(src_in_zp, scale32);
+        int32_t acc_hi = dst_acc >> mul_hi_shift;
+
+        int32_t dst_acc_shf_casted = mli_math_asr_rnd_fx<int32_t>(acc_hi, scale_shift + scale_norm + src_norm - mul_hi_shift);
+        int32_t dst_val = mli_math_add_fx<int32_t>(dst_acc_shf_casted, out_zp);
+        *dst_tensor_arr = mli_math_cast_fx<int32_t, out_T>(dst_val, 0);
+    } else {
+        int16_t src_in_zp = mli_math_sub_fx<int16_t>(*src_tensor_arr, in_zp);
+        acc_T dst_acc = mli_math_mul_fx<int16_t, acc_T>(src_in_zp, scale);
+        acc_T dst_acc_shf_casted = mli_math_asr_rnd_fx<acc_T>(dst_acc, scale_shift);
+        acc_T dst_val = mli_math_add_fx<acc_T>(dst_acc_shf_casted, out_zp);
+        *dst_tensor_arr = mli_math_cast_fx<acc_T, out_T>(dst_val, 0);
+    }
+}
+
 
 namespace mli {
 namespace hlp {
@@ -26,9 +57,6 @@ template <typename in_T, typename out_T, typename acc_T>
 mli_status compute_convert_quantized_data(const mli_tensor * src, mli_tensor * dst) {
     mli_prv_fx_init_dsp_ctrl();
 
-    /* If the accumulator is int64_t, so int32_t should be used for multiplying. */
-    typedef typename std::conditional<std::is_same<acc_T, int64_t>::value, int32_t, int16_t>::type mul_T;
-
     /* Get Generic Private Tensors */
     auto src_prv = mli_prv_get_generic_tensor<MLI_PTR(in_T)>(src);
     auto dst_prv = mli_prv_get_generic_tensor<MLI_OUT_PTR(out_T)>(dst);
@@ -63,10 +91,10 @@ mli_status compute_convert_quantized_data(const mli_tensor * src, mli_tensor * d
         /* Calculate scale and scaled zero point. */
         mli::krn::s8asym_quant_params params;
         mli::krn::define_requant_params(src, dst, &params, scale_idx);
-        const int16_t scale_shift = params.shift;
+        const int16_t scale_shift = mli_math_min_fx(params.shift, (int16_t) ((sizeof(acc_T) * 8) - 1));
         const int16_t scale = params.scale;
-        int16_t in_zp = mli_hlp_tensor_zero_offset(src, scale_idx);
-        int16_t out_zp = mli_hlp_tensor_zero_offset(dst, scale_idx);
+        const int16_t in_zp = mli_hlp_tensor_zero_offset(src, scale_idx);
+        const int16_t out_zp = mli_hlp_tensor_zero_offset(dst, scale_idx);
         /* Calculate borders across all dimensions for slice where this scale is applicable */
         int dim_start[MLI_MAX_RANK] = { 0 };
         int dim_end[MLI_MAX_RANK] = { 0 };
@@ -84,11 +112,8 @@ mli_status compute_convert_quantized_data(const mli_tensor * src, mli_tensor * d
                         const int dst_pos = POS(&dst_prv, dim0_idx, dim1_idx, dim2_idx, dim3_idx);
                         MLI_ASSERT(src_pos < src_tensor_size);
                         MLI_ASSERT(dst_pos < dst_tensor_size);
-                        mul_T src_in_zp = mli_math_sub_fx<mul_T>(src_tensor_arr[src_pos], in_zp);
-                        acc_T dst_acc = mli_math_mul_fx<mul_T, acc_T>(src_in_zp, scale);
-                        acc_T dst_acc_shf_casted = mli_math_asr_rnd_fx<acc_T>(dst_acc, scale_shift);
-                        acc_T dst_val = mli_math_add_fx<acc_T>(dst_acc_shf_casted, out_zp);
-                        dst_tensor_arr[dst_pos] = mli_math_cast_fx<acc_T, out_T>(dst_val, 0);
+                        calc_convert<in_T, out_T, acc_T>(&src_tensor_arr[src_pos], &dst_tensor_arr[dst_pos],
+                                                         in_zp, scale, scale_shift, out_zp);
                     }
                 }
             }
@@ -137,7 +162,7 @@ mli_status convert_float_data(const mli_tensor * src, mli_tensor * dst, convert_
 
     const mli_tensor* tensor = nullptr;
     const mli_tensor* float_tensor = nullptr;
-    
+
     /* Defining float_tensor and tensor depending on current conversion direction */
     if (mode == mli::hlp::QUANTIZE) {
         float_tensor = src;
@@ -171,14 +196,16 @@ mli_status convert_float_data(const mli_tensor * src, mli_tensor * dst, convert_
     /* Transformation will be applied on slices across scales dimension (or all tensor) */
     for (int scale_idx = 0; scale_idx < scales_num; ++scale_idx) {
         /* Calculate current scale and zero offset */
-        float scale_val;
+        float scale_val = 1.0;
+        int8_t frac_bits = mli_hlp_tensor_scale_shift(tensor, scale_idx);
+        float scale = (float) mli_hlp_tensor_scale(tensor, scale_idx);
         if (mode == mli::hlp::QUANTIZE) {
-            scale_val = (float)((int64_t)1l << mli_hlp_tensor_scale_shift(tensor, scale_idx));
-            scale_val = scale_val / (float)mli_hlp_tensor_scale(tensor, scale_idx);
-        } else if (mode == mli::hlp::DEQUANTIZE) {
-            scale_val = (float)mli_hlp_tensor_scale(tensor, scale_idx);
-            scale_val = scale_val / (float)((int64_t)1l << mli_hlp_tensor_scale_shift(tensor, scale_idx));
+            scale = 1.0 / scale;
+            scale_val = ldexp(scale, ((int32_t) frac_bits));
+        } else {
+            scale_val = ldexp(scale, -((int32_t) frac_bits));
         }
+
         int16_t zero_offset = mli_hlp_tensor_zero_offset(tensor, scale_idx);
 
         /* Calculate borders across all dimensions for slice where this scale is applicable */

lib/src/helpers/src/impl/mli_hlp_convert_tensor_vdsp.h

@@ -16,6 +16,7 @@
 #include "mli_prv_tensor.h"
 #include "mli_types.h"
 
+
 namespace mli {
 namespace hlp {
 namespace vdsp {
@@ -28,13 +29,12 @@ static MLI_FORCE_INLINE vNx4int_t calc_convert(
         const int16_t shift,
         const int16_t in_zp,
         const int16_t out_zp) {
-
-    int shift_right = mli_math_max_fx(shift, 0);
+    constexpr int max_shift = 31;
+    int shift_right = mli_math_min_fx(mli_math_max_fx(shift, 0), max_shift);
     int shift_left = mli_math_max_fx(-shift, 0);
 #ifdef ROUND_UP
     uint32_t one = 1u;
     int32_t offset = (one << shift_right) >> 1;
-            offset += (int32_t)out_zp << shift_right;
 #else
     #error Rounding mode not supported
 #endif
@@ -45,6 +45,7 @@ static MLI_FORCE_INLINE vNx4int_t calc_convert(
                 dst_val = mli_math_add_fx<vNx4int_t>(dst_val, offset);
                 dst_val = mli_math_asr_fx(dst_val, shift_right);
                 dst_val = mli_math_asl_fx(dst_val, shift_left);
+                dst_val = mli_math_add_fx<vNx4int_t>(dst_val, (int32_t) out_zp);
 
     return dst_val;
 }
@@ -55,13 +56,12 @@ static MLI_FORCE_INLINE vNx4int_t calc_convert(
         const int16_t shift,
         const int16_t in_zp,
         const int16_t out_zp) {
-
-    int shift_right = mli_math_max_fx(shift, 0);
+    constexpr int max_shift = 31;
+    int shift_right = mli_math_min_fx(mli_math_max_fx(shift, 0), max_shift);
     int shift_left = mli_math_max_fx(-shift, 0);
 #ifdef ROUND_UP
     uint32_t one = 1u;
     int32_t offset = (one << shift_right) >> 1;
-            offset += (int32_t)out_zp << shift_right;
 #else
     #error Rounding mode not supported
 #endif
@@ -70,6 +70,7 @@ static MLI_FORCE_INLINE vNx4int_t calc_convert(
                 dst_val = mli_math_add_fx<vNx4int_t>(dst_val, offset);
                 dst_val = mli_math_asr_fx(dst_val, shift_right);
                 dst_val = mli_math_asl_fx(dst_val, shift_left);
+                dst_val = mli_math_add_fx<vNx4int_t>(dst_val, (int32_t) out_zp);
 
     return dst_val;
 }
@@ -80,60 +81,31 @@ static MLI_FORCE_INLINE vNx4int_t calc_convert(
         const int16_t shift,
         const int16_t in_zp,
         const int16_t out_zp) {
-
-    constexpr int mul_pre_shift = 16;
-
-    if( shift > mul_pre_shift ) {
-        constexpr int mul_hi_shift = 32;
-        int total_shift = shift - (mul_hi_shift - mul_pre_shift);
-        int shift_right = mli_math_max_fx(total_shift, 1);
-        int shift_left = mli_math_max_fx(1 - total_shift, 0);
-
-        vNx4int_t src_in_zp = mli_math_sub(input, (int32_t)in_zp);
-                  src_in_zp = mli_math_asl_fx(src_in_zp, shift_left);
-        auto res = mli_math_mul_fx_high(src_in_zp, ((int32_t)scale << mul_pre_shift));
-             res = mli_math_asr_rnd_fx(res, shift_right);
-             res = mli_math_add_fx<vNx4int_t>(res, out_zp);
-
-        return res;
-    } else {
-        /* input = 2^16 * (input_hi) + input_lo
-         * input * scale = (2^16 * (input_hi) + input_lo) * scale
-         *               = 2^16 * (input_hi * scale) + (input_lo * scale)
-         * input * scale * 2^(-shift) = (2^16 * (input_hi * scale) + (input_lo * scale)) * (2^(-shift))
-         *                            = (input_hi * scale) * 2^(-(shift - 16)) + (input_lo * scale)) * (2^(-shift)
-         *                            = res_hi + res_lo
-         * where res_hi = (input_hi * scale) * 2^(-(shift - 16))
-         * and   res_lo = (input_lo * scale)) * (2^(-shift)
-         */
-        int shift_hi = shift - mul_pre_shift;
-        int shift_hi_right = mli_math_max_fx( shift_hi, 0);
-        int shift_hi_left  = mli_math_max_fx(-shift_hi, 0);
-        int shift_lo_right = mli_math_max_fx( shift, 0);
-        int shift_lo_left  = mli_math_max_fx(-shift, 0);
-        vNx4int_t src_in_zp = mli_math_sub(input, (int32_t)in_zp);
-        auto input_lo  = to_vNx4ushort_t(src_in_zp & 0xFFFF);
-        auto input_hi  = to_vNx4short_t(src_in_zp >> mul_pre_shift);
-        auto res_lo = mli_math_mul_su_fx<vNx4short_t, vNx4ushort_t, vNx4accint_t>(scale, input_lo);
-             res_lo = mli_math_asl_fx(res_lo, shift_lo_left);
-             res_lo = mli_math_asr_rnd_fx(res_lo, shift_lo_right);
-        auto res_hi = mli_math_mul_fx<vNx4short_t, vNx4accint_t>(input_hi, scale);
-             res_hi = mli_math_asl_fx(res_hi, shift_hi_left);
-             res_hi = mli_math_asr_fx(res_hi, shift_hi_right);
-
-        auto res = mli_math_add(res_lo, res_hi);
-             res = mli_math_add(res, (vNx4int_t)out_zp);
-
-        return mli_math_acc_cast_fx<vNx4int_t, vNx4accint_t>(res);
-    }
+    constexpr int mul_hi_shift = 32;
+    constexpr int max_int_shift = 31;
+
+    vNx4int_t src_in_zp = mli_math_sub(input, (int32_t)in_zp);
+    vNx4int_t src_norm = mli_math_norm_fx<vNx4int_t, vNx4int_t>(src_in_zp);
+    src_in_zp = mli_math_asl_fx<vNx4int_t, vNx4int_t>(src_in_zp, src_norm);
+
+    int32_t scale_norm = mli_math_norm_fx<int32_t, int32_t>((int32_t) scale);
+    int32_t scale_shifted = ((int32_t) scale) << scale_norm;
+    vNx4int_t res = mli_math_mul_fx_high(src_in_zp, scale_shifted);
+    vNx4int_t total_shift = mli_math_add_fx<vNx4int_t>(src_norm, (scale_norm - mul_hi_shift + shift));
+    vNx4int_t shift_left = mli_math_max_fx(-total_shift, 0);
+    vNx4int_t shift_right = mli_math_min_fx(mli_math_max_fx(total_shift, 0), max_int_shift);
+    vNx4int_t res_shifted = mli_math_asr_rnd_fx(res, shift_right);
+    res_shifted = mli_math_asl_fx(res_shifted, shift_left);
+    res_shifted = mli_math_add_fx<vNx4int_t>(res_shifted, (int32_t) out_zp);
+    return res_shifted;
 }
 
 template <typename out_T>
 static MLI_FORCE_INLINE void store_convert(
         MLI_OUT_PTR(out_T) out_ptr,
         vNx4int_t output,
         int remaining_part = 0) {
-    
+
     typedef decltype(mli_prv_load_nx4_samples(out_ptr)) cast_type;
 
     if (remaining_part) {
@@ -165,7 +137,7 @@ static MLI_FORCE_INLINE void store_convert(
         const int out_stride,
         vNx4int_t output,
         int remaining_part = 0) {
-    
+
     typedef decltype(mli_prv_load_nx4_samples(out_ptr)) cast_type;
 
     if (remaining_part) {