Adjust loops handling

Deepdive543443 · Deepdive543443 · commit c3465dbca714 · 2026-04-18T11:30:38.000+08:00
diff --git a/src/layer/riscv/dequantize_riscv.cpp b/src/layer/riscv/dequantize_riscv.cpp
@@ -34,7 +34,6 @@ static void dequantize(const int* intptr, float* ptr, const Mat& scale_data, con
 #if __riscv_vector
     const size_t vlm1 = __riscv_vsetvlmax_e32m1();
     const size_t vlm2 = __riscv_vsetvlmax_e32m2();
-    bool vectorize = true;
     vfloat32m8_t _scale;
     if (scale_data.w == 1)
     {
@@ -45,22 +44,17 @@ static void dequantize(const int* intptr, float* ptr, const Mat& scale_data, con
         vfloat32m1_t _s = __riscv_vle32_v_f32m1(scale_data, vlm1);
         _scale = __riscv_vcreate_v_f32m1_f32m8(_s, _s, _s, _s, _s, _s, _s, _s);
     }
-    else if (elempack == vlm2)
+    else if (elempack == vlm2) // VLENB < Pack 8
     {
         vfloat32m2_t _s = __riscv_vle32_v_f32m2(scale_data, vlm2);
         _scale = __riscv_vcreate_v_f32m2_f32m8(_s, _s, _s, _s);
     }
-    else
-    {
-        vectorize = false;
-    }
 #endif // __riscv_vector
 
     if (bias_data.w == 0)
     {
-        int i = 0;
 #if __riscv_vector
-        int n = vectorize ? size : 0;
+        int n = size;
         while (n > 0)
         {
             size_t vl = __riscv_vsetvl_e32m8(n);
@@ -72,21 +66,18 @@ static void dequantize(const int* intptr, float* ptr, const Mat& scale_data, con
             ptr += vl;
             n -= vl;
         }
-
-        i += (size - n);
-#endif // __riscv_vector
-        for (; i < size; i++)
+#else  // __riscv_vector
+        for (int i = 0; i < size; i++)
         {
             *ptr = *intptr * scale;
             intptr++;
             ptr++;
         }
+#endif // __riscv_vector
     }
     else
     {
         float bias = bias_data[0];
-
-        int i = 0;
 #if __riscv_vector
         vfloat32m8_t _bias;
         if (bias_data.w == 1)
@@ -98,17 +89,13 @@ static void dequantize(const int* intptr, float* ptr, const Mat& scale_data, con
             vfloat32m1_t _b = __riscv_vle32_v_f32m1(bias_data, vlm1);
             _bias = __riscv_vcreate_v_f32m1_f32m8(_b, _b, _b, _b, _b, _b, _b, _b);
         }
-        else if (elempack == vlm2)
+        else if (elempack == vlm2) // VLENB < Pack 8
         {
             vfloat32m2_t _b = __riscv_vle32_v_f32m2(bias_data, vlm2);
             _bias = __riscv_vcreate_v_f32m2_f32m8(_b, _b, _b, _b);
         }
-        else
-        {
-            vectorize = false;
-        }
 
-        int n = vectorize ? size : 0;
+        int n = size;
         while (n > 0)
         {
             size_t vl = __riscv_vsetvl_e32m8(n);
@@ -120,15 +107,14 @@ static void dequantize(const int* intptr, float* ptr, const Mat& scale_data, con
             ptr += vl;
             n -= vl;
         }
-
-        i += (size - n);
-#endif // __riscv_vector
-        for (; i < size; i++)
+#else  // __riscv_vector
+        for (int i = 0; i < size; i++)
         {
             *ptr = *intptr * scale + bias;
             intptr++;
             ptr++;
         }
+#endif // __riscv_vector
     }
 }
 
diff --git a/src/layer/riscv/dequantize_riscv_zfh.cpp b/src/layer/riscv/dequantize_riscv_zfh.cpp
@@ -20,7 +20,6 @@ static void dequantize_fp16s(const int* intptr, __fp16* ptr, const Mat& scale_da
 #if __riscv_vector
     const size_t vlm1 = __riscv_vsetvlmax_e32m1();
     const size_t vlm2 = __riscv_vsetvlmax_e32m2();
-    bool vectorize = true;
     vfloat32m8_t _scale;
     if (scale_data.w == 1)
     {
@@ -31,22 +30,17 @@ static void dequantize_fp16s(const int* intptr, __fp16* ptr, const Mat& scale_da
         vfloat32m1_t _s = __riscv_vle32_v_f32m1(scale_data, vlm1);
         _scale = __riscv_vcreate_v_f32m1_f32m8(_s, _s, _s, _s, _s, _s, _s, _s);
     }
-    else if (elempack == vlm2)
+    else if (elempack == vlm2) // VLENB < Pack 8
     {
         vfloat32m2_t _s = __riscv_vle32_v_f32m2(scale_data, vlm2);
         _scale = __riscv_vcreate_v_f32m2_f32m8(_s, _s, _s, _s);
     }
-    else
-    {
-        vectorize = false;
-    }
 #endif // __riscv_vector
 
     if (bias_data.w == 0)
     {
-        int i = 0;
 #if __riscv_vector
-        int n = vectorize ? size : 0;
+        int n = size;
         while (n > 0)
         {
             size_t vl = __riscv_vsetvl_e16m4(n);
@@ -58,21 +52,18 @@ static void dequantize_fp16s(const int* intptr, __fp16* ptr, const Mat& scale_da
             ptr += vl;
             n -= vl;
         }
-
-        i += (size - n);
-#endif // __riscv_vector
-        for (; i < size; i++)
+#else  // __riscv_vector
+        for (int i = 0; i < size; i++)
         {
             *ptr = (__fp16)((float)*intptr * scale);
             intptr++;
             ptr++;
         }
+#endif // __riscv_vector
     }
     else
     {
         float bias = bias_data[0];
-
-        int i = 0;
 #if __riscv_vector
         vfloat32m8_t _bias;
         if (bias_data.w == 1)
@@ -84,17 +75,13 @@ static void dequantize_fp16s(const int* intptr, __fp16* ptr, const Mat& scale_da
             vfloat32m1_t _b = __riscv_vle32_v_f32m1(bias_data, vlm1);
             _bias = __riscv_vcreate_v_f32m1_f32m8(_b, _b, _b, _b, _b, _b, _b, _b);
         }
-        else if (elempack == vlm2)
+        else if (elempack == vlm2) // VLENB < Pack 8
         {
             vfloat32m2_t _b = __riscv_vle32_v_f32m2(bias_data, vlm2);
             _bias = __riscv_vcreate_v_f32m2_f32m8(_b, _b, _b, _b);
         }
-        else
-        {
-            vectorize = false;
-        }
 
-        int n = vectorize ? size : 0;
+        int n = size;
         while (n > 0)
         {
             size_t vl = __riscv_vsetvl_e16m4(n);
@@ -106,15 +93,14 @@ static void dequantize_fp16s(const int* intptr, __fp16* ptr, const Mat& scale_da
             ptr += vl;
             n -= vl;
         }
-
-        i += (size - n);
-#endif // __riscv_vector
-        for (; i < size; i++)
+#else  // __riscv_vector
+        for (int i = 0; i < size; i++)
         {
             *ptr = (__fp16)((float)*intptr * scale + bias);
             intptr++;
             ptr++;
         }
+#endif // __riscv_vector
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,6 @@ static void dequantize(const int* intptr, float* ptr, const Mat& scale_data, con`
`34`	`34`	`#if __riscv_vector`
`35`	`35`	`const size_t vlm1 = __riscv_vsetvlmax_e32m1();`
`36`	`36`	`const size_t vlm2 = __riscv_vsetvlmax_e32m2();`
`37`		`- bool vectorize = true;`
`38`	`37`	`vfloat32m8_t _scale;`
`39`	`38`	`if (scale_data.w == 1)`
`40`	`39`	`{`
`@@ -45,22 +44,17 @@ static void dequantize(const int* intptr, float* ptr, const Mat& scale_data, con`
`45`	`44`	`vfloat32m1_t _s = __riscv_vle32_v_f32m1(scale_data, vlm1);`
`46`	`45`	`_scale = __riscv_vcreate_v_f32m1_f32m8(_s, _s, _s, _s, _s, _s, _s, _s);`
`47`	`46`	`}`
`48`		`- else if (elempack == vlm2)`
	`47`	`+ else if (elempack == vlm2) // VLENB < Pack 8`
`49`	`48`	`{`
`50`	`49`	`vfloat32m2_t _s = __riscv_vle32_v_f32m2(scale_data, vlm2);`
`51`	`50`	`_scale = __riscv_vcreate_v_f32m2_f32m8(_s, _s, _s, _s);`
`52`	`51`	`}`
`53`		`- else`
`54`		`- {`
`55`		`- vectorize = false;`
`56`		`- }`
`57`	`52`	`#endif // __riscv_vector`
`58`	`53`
`59`	`54`	`if (bias_data.w == 0)`
`60`	`55`	`{`
`61`		`- int i = 0;`
`62`	`56`	`#if __riscv_vector`
`63`		`- int n = vectorize ? size : 0;`
	`57`	`+ int n = size;`
`64`	`58`	`while (n > 0)`
`65`	`59`	`{`
`66`	`60`	`size_t vl = __riscv_vsetvl_e32m8(n);`
`@@ -72,21 +66,18 @@ static void dequantize(const int* intptr, float* ptr, const Mat& scale_data, con`
`72`	`66`	`ptr += vl;`
`73`	`67`	`n -= vl;`
`74`	`68`	`}`
`75`		`-`
`76`		`- i += (size - n);`
`77`		`-#endif // __riscv_vector`
`78`		`- for (; i < size; i++)`
	`69`	`+#else // __riscv_vector`
	`70`	`+ for (int i = 0; i < size; i++)`
`79`	`71`	`{`
`80`	`72`	`ptr = intptr * scale;`
`81`	`73`	`intptr++;`
`82`	`74`	`ptr++;`
`83`	`75`	`}`
	`76`	`+#endif // __riscv_vector`
`84`	`77`	`}`
`85`	`78`	`else`
`86`	`79`	`{`
`87`	`80`	`float bias = bias_data[0];`
`88`		`-`
`89`		`- int i = 0;`
`90`	`81`	`#if __riscv_vector`
`91`	`82`	`vfloat32m8_t _bias;`
`92`	`83`	`if (bias_data.w == 1)`
`@@ -98,17 +89,13 @@ static void dequantize(const int* intptr, float* ptr, const Mat& scale_data, con`
`98`	`89`	`vfloat32m1_t _b = __riscv_vle32_v_f32m1(bias_data, vlm1);`
`99`	`90`	`_bias = __riscv_vcreate_v_f32m1_f32m8(_b, _b, _b, _b, _b, _b, _b, _b);`
`100`	`91`	`}`
`101`		`- else if (elempack == vlm2)`
	`92`	`+ else if (elempack == vlm2) // VLENB < Pack 8`
`102`	`93`	`{`
`103`	`94`	`vfloat32m2_t _b = __riscv_vle32_v_f32m2(bias_data, vlm2);`
`104`	`95`	`_bias = __riscv_vcreate_v_f32m2_f32m8(_b, _b, _b, _b);`
`105`	`96`	`}`
`106`		`- else`
`107`		`- {`
`108`		`- vectorize = false;`
`109`		`- }`
`110`	`97`
`111`		`- int n = vectorize ? size : 0;`
	`98`	`+ int n = size;`
`112`	`99`	`while (n > 0)`
`113`	`100`	`{`
`114`	`101`	`size_t vl = __riscv_vsetvl_e32m8(n);`
`@@ -120,15 +107,14 @@ static void dequantize(const int* intptr, float* ptr, const Mat& scale_data, con`
`120`	`107`	`ptr += vl;`
`121`	`108`	`n -= vl;`
`122`	`109`	`}`
`123`		`-`
`124`		`- i += (size - n);`
`125`		`-#endif // __riscv_vector`
`126`		`- for (; i < size; i++)`
	`110`	`+#else // __riscv_vector`
	`111`	`+ for (int i = 0; i < size; i++)`
`127`	`112`	`{`
`128`	`113`	`ptr = intptr * scale + bias;`
`129`	`114`	`intptr++;`
`130`	`115`	`ptr++;`
`131`	`116`	`}`
	`117`	`+#endif // __riscv_vector`
`132`	`118`	`}`
`133`	`119`	`}`
`134`	`120`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@ static void dequantize_fp16s(const int* intptr, __fp16* ptr, const Mat& scale_da`
`20`	`20`	`#if __riscv_vector`
`21`	`21`	`const size_t vlm1 = __riscv_vsetvlmax_e32m1();`
`22`	`22`	`const size_t vlm2 = __riscv_vsetvlmax_e32m2();`
`23`		`- bool vectorize = true;`
`24`	`23`	`vfloat32m8_t _scale;`
`25`	`24`	`if (scale_data.w == 1)`
`26`	`25`	`{`
`@@ -31,22 +30,17 @@ static void dequantize_fp16s(const int* intptr, __fp16* ptr, const Mat& scale_da`
`31`	`30`	`vfloat32m1_t _s = __riscv_vle32_v_f32m1(scale_data, vlm1);`
`32`	`31`	`_scale = __riscv_vcreate_v_f32m1_f32m8(_s, _s, _s, _s, _s, _s, _s, _s);`
`33`	`32`	`}`
`34`		`- else if (elempack == vlm2)`
	`33`	`+ else if (elempack == vlm2) // VLENB < Pack 8`
`35`	`34`	`{`
`36`	`35`	`vfloat32m2_t _s = __riscv_vle32_v_f32m2(scale_data, vlm2);`
`37`	`36`	`_scale = __riscv_vcreate_v_f32m2_f32m8(_s, _s, _s, _s);`
`38`	`37`	`}`
`39`		`- else`
`40`		`- {`
`41`		`- vectorize = false;`
`42`		`- }`
`43`	`38`	`#endif // __riscv_vector`
`44`	`39`
`45`	`40`	`if (bias_data.w == 0)`
`46`	`41`	`{`
`47`		`- int i = 0;`
`48`	`42`	`#if __riscv_vector`
`49`		`- int n = vectorize ? size : 0;`
	`43`	`+ int n = size;`
`50`	`44`	`while (n > 0)`
`51`	`45`	`{`
`52`	`46`	`size_t vl = __riscv_vsetvl_e16m4(n);`
`@@ -58,21 +52,18 @@ static void dequantize_fp16s(const int* intptr, __fp16* ptr, const Mat& scale_da`
`58`	`52`	`ptr += vl;`
`59`	`53`	`n -= vl;`
`60`	`54`	`}`
`61`		`-`
`62`		`- i += (size - n);`
`63`		`-#endif // __riscv_vector`
`64`		`- for (; i < size; i++)`
	`55`	`+#else // __riscv_vector`
	`56`	`+ for (int i = 0; i < size; i++)`
`65`	`57`	`{`
`66`	`58`	`ptr = (__fp16)((float)intptr * scale);`
`67`	`59`	`intptr++;`
`68`	`60`	`ptr++;`
`69`	`61`	`}`
	`62`	`+#endif // __riscv_vector`
`70`	`63`	`}`
`71`	`64`	`else`
`72`	`65`	`{`
`73`	`66`	`float bias = bias_data[0];`
`74`		`-`
`75`		`- int i = 0;`
`76`	`67`	`#if __riscv_vector`
`77`	`68`	`vfloat32m8_t _bias;`
`78`	`69`	`if (bias_data.w == 1)`
`@@ -84,17 +75,13 @@ static void dequantize_fp16s(const int* intptr, __fp16* ptr, const Mat& scale_da`
`84`	`75`	`vfloat32m1_t _b = __riscv_vle32_v_f32m1(bias_data, vlm1);`
`85`	`76`	`_bias = __riscv_vcreate_v_f32m1_f32m8(_b, _b, _b, _b, _b, _b, _b, _b);`
`86`	`77`	`}`
`87`		`- else if (elempack == vlm2)`
	`78`	`+ else if (elempack == vlm2) // VLENB < Pack 8`
`88`	`79`	`{`
`89`	`80`	`vfloat32m2_t _b = __riscv_vle32_v_f32m2(bias_data, vlm2);`
`90`	`81`	`_bias = __riscv_vcreate_v_f32m2_f32m8(_b, _b, _b, _b);`
`91`	`82`	`}`
`92`		`- else`
`93`		`- {`
`94`		`- vectorize = false;`
`95`		`- }`
`96`	`83`
`97`		`- int n = vectorize ? size : 0;`
	`84`	`+ int n = size;`
`98`	`85`	`while (n > 0)`
`99`	`86`	`{`
`100`	`87`	`size_t vl = __riscv_vsetvl_e16m4(n);`
`@@ -106,15 +93,14 @@ static void dequantize_fp16s(const int* intptr, __fp16* ptr, const Mat& scale_da`
`106`	`93`	`ptr += vl;`
`107`	`94`	`n -= vl;`
`108`	`95`	`}`
`109`		`-`
`110`		`- i += (size - n);`
`111`		`-#endif // __riscv_vector`
`112`		`- for (; i < size; i++)`
	`96`	`+#else // __riscv_vector`
	`97`	`+ for (int i = 0; i < size; i++)`
`113`	`98`	`{`
`114`	`99`	`ptr = (__fp16)((float)intptr * scale + bias);`
`115`	`100`	`intptr++;`
`116`	`101`	`ptr++;`
`117`	`102`	`}`
	`103`	`+#endif // __riscv_vector`
`118`	`104`	`}`
`119`	`105`	`}`
`120`	`106`