The issues raised in the comments have been addressed.

Co-authored-by: typer-J <2236066784@qq.com>

Co-authored-by: Sherlockzhangjinge <zjgzhangjinge@outlook.com>

Co-authored-by: lyd1992 <liuyudong@iscas.ac.cn>

Author: jxgxxx

.clang-format

@@ -0,0 +1,60 @@
+---
+# MNN C++ Code Style
+# Based on Google style with project-specific overrides
+# Usage: clang-format -i -style=file <file>
+
+BasedOnStyle: Google
+Language: Cpp
+
+# Indentation
+IndentWidth: 4
+ContinuationIndentWidth: 4
+AccessModifierOffset: -4
+ConstructorInitializerIndentWidth: 4
+
+# Line width
+ColumnLimit: 120
+
+# Braces
+BreakBeforeBraces: Attach
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortBlocksOnASingleLine: false
+
+# Includes
+SortIncludes: Never
+IncludeBlocks: Preserve
+
+# Alignment
+# Note: The codebase has some manual consecutive-assignment alignment, but enabling
+# AlignConsecutiveAssignments globally causes more harm than good (misaligns isolated lines).
+# Leave it off; manually aligned blocks are preserved as-is when untouched.
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignTrailingComments: true
+
+# Pointers & References
+DerivePointerAlignment: false
+PointerAlignment: Left
+
+# Misc
+SpaceAfterCStyleCast: false
+SpaceBeforeParens: ControlStatements
+SpacesBeforeTrailingComments: 1
+Standard: c++11
+TabWidth: 4
+UseTab: Never
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+FixNamespaceComments: true
+ReflowComments: true
+
+# Penalty tuning (prefer not breaking certain constructs)
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+---
+

source/backend/cpu/compute/CommonOptFunction.cpp

@@ -18,4 +18,4 @@ void MNNDynamicUpdateConvBiasScale_RVV(float* newbias, float* oldbias, float* we
 
         __riscv_vse32_v_f32m4(newbias + i, v_new, vl);
     }
-}
+}

source/backend/cpu/riscv/rvv/MNNC3ToBGR555.cpp

@@ -0,0 +1,6 @@
+#include <stdint.h>
+void MNNGetMatMulPackMode_RVV(int* eP, int* lP, int* hP) {
+    *eP = 16;
+    *lP = 1;
+    *hP = 4;
+}

source/backend/cpu/riscv/rvv/MNNDynamicUpdateConvBiasScale.cpp

@@ -1,9 +1,7 @@
 #include <riscv_vector.h>
-#include <algorithm>
+#include <stdint.h>
 
-#define TILE_E_SIZE 1024
-
-void MNNPackC4ForMatMul_A(float *destOrigin, float const **sourceGroup, const int32_t *info, const int32_t *el) {
+void MNNPackC4ForMatMul_A_RVV(float* destOrigin, float const** sourceGroup, const int32_t* info, const int32_t* el) {
     int number = info[0];
     int eReal = info[1];
     int eDest = info[2];
@@ -14,54 +12,27 @@ void MNNPackC4ForMatMul_A(float *destOrigin, float const **sourceGroup, const in
         int l = el[4 * n + 1];
         int eOffset = el[4 * n + 2];
         int lOffset = el[4 * n + 3];
-        auto destBase = destOrigin + lOffset * eDest + eOffset;
-        auto source = sourceGroup[n];        
-        int limit = l / 4 * 4; 
-        int x = 0;
-
-        for (; x < limit; x += 4) {
-            auto xC = x / 4;
-            const float *sourcePtrBase = source + xC * eReal * 4;
-            float *destPtrCol0 = destBase + (x + 0) * eDest;
-            float *destPtrCol1 = destBase + (x + 1) * eDest;
-            float *destPtrCol2 = destBase + (x + 2) * eDest;
-            float *destPtrCol3 = destBase + (x + 3) * eDest;
+        auto dest = destOrigin + lOffset * eDest + eOffset;
+        auto source = sourceGroup[n];
 
-            for (int yBase = 0; yBase < e; yBase += TILE_E_SIZE) {
-                int eBlock = std::min(e - yBase, TILE_E_SIZE);
+        for (int y = 0; y < e; ++y) {
+            auto yR = y % eDest;
+            auto destY = dest + yR;
+            auto sourceY = source + y * 4 * offset;
 
-                for (int yOffset = 0; yOffset < eBlock; ) {
-                    size_t vl = __riscv_vsetvl_e32m8(eBlock - yOffset);                    
-                    const float *sourceYPtr = sourcePtrBase + (yBase + yOffset) * 4 * offset;
-                    const size_t sourceStride = 4 * offset * sizeof(float);
+            int x = 0;
+            size_t vl = __riscv_vsetvl_e32m1(4);
 
-                    vfloat32m8_t col0 = __riscv_vlse32_v_f32m8(sourceYPtr + 0, sourceStride, vl);
-                    vfloat32m8_t col1 = __riscv_vlse32_v_f32m8(sourceYPtr + 1, sourceStride, vl);
-                    vfloat32m8_t col2 = __riscv_vlse32_v_f32m8(sourceYPtr + 2, sourceStride, vl);
-                    vfloat32m8_t col3 = __riscv_vlse32_v_f32m8(sourceYPtr + 3, sourceStride, vl);
-                    
-                    __riscv_vse32_v_f32m8(destPtrCol0 + yBase + yOffset, col0, vl);
-                    __riscv_vse32_v_f32m8(destPtrCol1 + yBase + yOffset, col1, vl);
-                    __riscv_vse32_v_f32m8(destPtrCol2 + yBase + yOffset, col2, vl);
-                    __riscv_vse32_v_f32m8(destPtrCol3 + yBase + yOffset, col3, vl);
-
-                    yOffset += vl;
-                }
+            for (; x <= l - 4; x += 4) {
+                int xC = x / 4;
+                vfloat32m1_t v_src = __riscv_vle32_v_f32m1(sourceY + xC * eReal * 4, vl);
+                __riscv_vsse32_v_f32m1(destY + x * eDest, eDest * sizeof(float), v_src, vl);
             }
-        }
-        
-        for (; x < l; ++x) {
-            auto xC = x / 4;
-            auto xR = x % 4;
-            const float* sourcePtrBase = source + xC * eReal * 4 + xR;
-            float* destPtrCol = destBase + x * eDest;
 
-            for (int yBase = 0; yBase < e; yBase += TILE_E_SIZE) {
-                int eBlock = std::min(e - yBase, TILE_E_SIZE);
-                for (int yOffset = 0; yOffset < eBlock; ++yOffset) {
-                    int y = yBase + yOffset;
-                    destPtrCol[y] = sourcePtrBase[y * 4 * offset];
-                }
+            for (; x < l; ++x) {
+                int xR = x % 4;
+                int xC = x / 4;
+                destY[x * eDest] = sourceY[xC * eReal * 4 + xR];
             }
         }
     }

source/backend/cpu/riscv/rvv/MNNGetMatMulPackMode.cpp

@@ -3,17 +3,16 @@
 #include <stdint.h>
 #include <stddef.h>
 
-#define SME2_MATMUL_LP 1
-#define SME2_MATMUL_HP 64
-#define ROUND_UP(x, y) (((x) + (y) - 1) / (y) * (y))
+#define RVV_MATMUL_LP 1
+#define RVV_MATMUL_HP 64
 
 void MNNPackForMatMul_B_RVV(float* destC, const float* sourceC, size_t h, size_t kernelsize, size_t ic,
                             bool transpose) {
     auto dest = (int32_t*)destC;
     auto source = (int32_t*)sourceC;
 
-    int LP = SME2_MATMUL_LP;
-    int HP = SME2_MATMUL_HP;
+    int LP = RVV_MATMUL_LP;
+    int HP = RVV_MATMUL_HP;
     auto l = kernelsize * ic;
 
     size_t dest_size = ROUND_UP(h, HP) * ROUND_UP(ic, LP) * kernelsize * 4;
@@ -66,4 +65,4 @@ void MNNPackForMatMul_B_RVV(float* destC, const float* sourceC, size_t h, size_t
             }
         }
     }
-}
+}

source/backend/cpu/riscv/rvv/MNNPackC4ForMatMul_A.cpp

@@ -1,70 +1,8 @@
-#include <riscv_vector.h>
-#include <algorithm>
-#include <limits>
 #include <stddef.h>
 
-#define UP_DIV(x, y) (((x) + (y) - 1) / (y))
-
-void MNNPackedMatMulFP32(float* C, const float* A, const float* B, const size_t* parameter, const float* postParameters,
-                         const float* bias, const float* k, const float* b) {
-    const size_t eSize = 16;
-
-    size_t aStride = parameter[0] / sizeof(float);
-    size_t l = parameter[1];
-    size_t h = parameter[2];
-    size_t cStride = parameter[3] / sizeof(float);
-    size_t bExtraStride = parameter[5] / sizeof(float);
-    size_t bStride = bExtraStride + l * 4;
-
-    size_t hC4 = UP_DIV(h, 4);
-
-    float minValue = -std::numeric_limits<float>::max();
-    float maxValue = std::numeric_limits<float>::max();
-    if (postParameters != nullptr) {
-        minValue = postParameters[2];
-        maxValue = postParameters[3];
-    }
-
-    size_t vl = __riscv_vsetvl_e32m4(eSize);
-
-    for (size_t y = 0; y < hC4; ++y) {
-        float* c_base = C + y * cStride;
-        const float* b_base = B + y * bStride;
-        const float* bias_y = bias ? bias + 4 * y : nullptr;
-
-        vfloat32m4_t acc0, acc1, acc2, acc3;
-        if (bias_y) {
-            acc0 = __riscv_vfmv_v_f_f32m4(bias_y[0], vl);
-            acc1 = __riscv_vfmv_v_f_f32m4(bias_y[1], vl);
-            acc2 = __riscv_vfmv_v_f_f32m4(bias_y[2], vl);
-            acc3 = __riscv_vfmv_v_f_f32m4(bias_y[3], vl);
-        } else {
-            acc0 = __riscv_vfmv_v_f_f32m4(0.0f, vl);
-            acc1 = __riscv_vfmv_v_f_f32m4(0.0f, vl);
-            acc2 = __riscv_vfmv_v_f_f32m4(0.0f, vl);
-            acc3 = __riscv_vfmv_v_f_f32m4(0.0f, vl);
-        }
-
-        for (size_t z = 0; z < l; ++z) {
-            vfloat32m4_t a_vec = __riscv_vle32_v_f32m4(A + z * aStride, vl);
-            const float* w_ptr = b_base + z * 4;
-
-            acc0 = __riscv_vfmacc_vf_f32m4(acc0, w_ptr[0], a_vec, vl);
-            acc1 = __riscv_vfmacc_vf_f32m4(acc1, w_ptr[1], a_vec, vl);
-            acc2 = __riscv_vfmacc_vf_f32m4(acc2, w_ptr[2], a_vec, vl);
-            acc3 = __riscv_vfmacc_vf_f32m4(acc3, w_ptr[3], a_vec, vl);
-        }
-
-        acc0 = __riscv_vfmin_vf_f32m4(__riscv_vfmax_vf_f32m4(acc0, minValue, vl), maxValue, vl);
-        acc1 = __riscv_vfmin_vf_f32m4(__riscv_vfmax_vf_f32m4(acc1, minValue, vl), maxValue, vl);
-        acc2 = __riscv_vfmin_vf_f32m4(__riscv_vfmax_vf_f32m4(acc2, minValue, vl), maxValue, vl);
-        acc3 = __riscv_vfmin_vf_f32m4(__riscv_vfmax_vf_f32m4(acc3, minValue, vl), maxValue, vl);
-
-        ptrdiff_t stride = 4 * sizeof(float);
-
-        __riscv_vsse32_v_f32m4(c_base + 0, stride, acc0, vl);
-        __riscv_vsse32_v_f32m4(c_base + 1, stride, acc1, vl);
-        __riscv_vsse32_v_f32m4(c_base + 2, stride, acc2, vl);
-        __riscv_vsse32_v_f32m4(c_base + 3, stride, acc3, vl);
-    }
-}
+void MNNPackedMatMulRemainFP32_RVV(float* C, const float* A, const float* B, size_t eSize, const size_t* parameter,
+                                   const float* postParameters, const float* bias, const float* k, const float* b);
+void MNNPackedMatMulFP32_RVV(float* C, const float* A, const float* B, const size_t* parameter,
+                             const float* postParameters, const float* bias, const float* k, const float* b) {
+    MNNPackedMatMulRemainFP32_RVV(C, A, B, 16, parameter, postParameters, bias, k, b);
+}

source/backend/cpu/riscv/rvv/MNNPackC4ForMatMul_A_RVV.cpp

@@ -2,10 +2,8 @@
 #include <algorithm>
 #include <limits>
 #include <stddef.h>
-
-#define UP_DIV(x, y) (((x) + (y) - 1) / (y))
-void MNNPackedMatMulRemainFP32(float* C, const float* A, const float* B, size_t eSize, const size_t* parameter,
-                               const float* postParameters, const float* bias, const float* k, const float* b) {
+void MNNPackedMatMulRemainFP32_RVV(float* C, const float* A, const float* B, size_t eSize, const size_t* parameter,
+                                   const float* postParameters, const float* bias, const float* k, const float* b) {
     if (eSize == 0)
         return;
 
@@ -67,4 +65,4 @@ void MNNPackedMatMulRemainFP32(float* C, const float* A, const float* B, size_t
         __riscv_vsse32_v_f32m4(c_base + 2, stride, acc2, vl);
         __riscv_vsse32_v_f32m4(c_base + 3, stride, acc3, vl);
     }
-}
+}