RISC-V 向量扩展 RVV 深度实战：VLA 编程模型与矩阵运算微架构优化

; vsetvli rd, rs1, vtypei
; rd = AVL（Application Vector Length）实际处理的元素数
; vtype[2:0]   = SEW (Selected Element Width): 8/16/32/64
; vtype[5:3]   = LMUL: 1/2/4/8 或 1/2/4/8 的 fraction (f8/f4/f2)
; vtype[6]     = vta: 向量尾部分治策略 (tail agnostic/policy)
; vtype[7]     = vma: 向量掩码不治策略 (mask agnostic/policy)
; vl CSR = min(AVL, VLMAX)  —— 硬件实际处理的元素数
; vstart CSR = 异常重启起点

vsetvli t0, a0, e32, m8, ta, ma
; SEW=32bit (float/int32), LMUL=8, VLMAX=8*(VLEN/32)
; ta=tail agnostic (尾部可忽略), ma=mask agnostic (掩码可忽略)

; 伪代码：RVV 自动 stripmining 处理任意长度向量
; 输入：a0=元素个数, a1=源地址, a2=目标地址

loop:
    vsetvli t0, a0, e32, m8, ta, ma  ; t0 = min(剩余, VLMAX)
    vle32.v v0, (a1)                   ; 加载 t0 个 float32
    vfmul.vf v8, v0, fa0               ; 向量*标量
    vse32.v v8, (a2)                   ; 存储结果

    add a1, a1, t0, 4                  ; 前进 t0*4 字节
    add a2, a2, t0, 4
    sub a0, a0, t0                     ; 减去已处理数
    bnez a0, loop                      ; 未处理完则继续

// RVV GEMM 伪代码：C[M][N] += A[M][K] x B[K][N]
// 内核维度: MR=4行 x NC=64列 (匹配 VLMAX)

void rvv_gemm_4x64(float *A, float *B, float *C, int M, int N, int K) {
    for (int i = 0; i < M; i += 4) {      // 4行面板
        for (int j = 0; j < N; j += 64) {  // 64列面板=VLMAX
            // 累加器: 4x64 = 256 个 float32
            vfloat32m8_t c0 = vfmv_v_f_f32m8(0.0, 64);
            vfloat32m8_t c1 = vfmv_v_f_f32m8(0.0, 64);
            vfloat32m8_t c2 = vfmv_v_f_f32m8(0.0, 64);
            vfloat32m8_t c3 = vfmv_v_f_f32m8(0.0, 64);

            for (int k = 0; k < K; k++) {
                vfloat32m8_t b = vle32_v_f32m8(&B[k*N + j], 64);
                c0 = vfmacc_vf_f32m8(c0, A[i*K+k], b, 64);
                c1 = vfmacc_vf_f32m8(c1, A[(i+1)*K+k], b, 64);
                c2 = vfmacc_vf_f32m8(c2, A[(i+2)*K+k], b, 64);
                c3 = vfmacc_vf_f32m8(c3, A[(i+3)*K+k], b, 64);
            }

            vse32_v_f32m8(&C[i*N + j], c0, 64);
            vse32_v_f32m8(&C[(i+1)*N + j], c1, 64);
            vse32_v_f32m8(&C[(i+2)*N + j], c2, 64);
            vse32_v_f32m8(&C[(i+3)*N + j], c3, 64);
        }
    }
}

; RVV 实现 atan2(y, x) via CORDIC 向量模式
; 输入：y向量在v0, x向量在v1 (N个float32)
; 输出：角度向量在v8 (N个float32)

cordic_atan2_vm:
    la      t0, cordic_table      ; 预计算 atan(2^-i) 表
    vle32.v v30, (t0)             ; 加载前 VLMAX 个校正值

    vmv.v.v v16, v1               ; X = x
    vmv.v.v v17, v0               ; Y = y
    vmv.v.v v8, zero              ; Z = 0 (角度累加器)

    li      s0, 20                ; 20 次迭代 (精度 ~1e-6)

cordic_loop:
    vmflt.vv v0, v17, zero        ; v0.mask = (Y < 0)

    vsra.vi v20, v17, s0          ; Y >> i
    vsra.vi v21, v16, s0          ; X >> i

    vadd.vv v24, v16, v20, v0.t   ; 条件加减法（利用掩码）
    vsub.vv v25, v16, v20, v0.t
    vmerge.vvm v16, v25, v24, v0  ; X_new

    vsub.vv v24, v17, v21, v0.t   ; Y_new 反号
    vadd.vv v25, v17, v21, v0.t
    vmerge.vvm v17, v25, v24, v0

    vsub.vv v24, v8, v30, v0.t    ; Z_new 角度
    vadd.vv v25, v8, v30, v0.t
    vmerge.vvm v8, v25, v24, v0

    addi    s0, s0, -1
    bnez    s0, cordic_loop
    ret

# QEMU 7.0+ 支持 RVV v1.0 仿真
qemu-riscv64 -cpu rv64,v=true,vlen=256,vext_spec=v1.0 ./program

# Docker 方式
docker pull riscv64/ubuntu:22.04
docker run --rm -v $PWD:/wk riscv64/ubuntu bash -c "cd /wk && gcc -march=rv64gcv -O3 gemm_rvv.c -o gemm"

# 香山处理器 (XiangShan) 提供周期精确仿真
git clone https://github.com/OpenXiangShan/XiangShan
cd XiangShan && make emu CONFIG=MinimalSimConfig
./build/emu -i ./ready-to-run/coremark-2-iteration.bin