Fix missing RVV gemm kernel descriptions and regenerate tests/benchmarks

PiperOrigin-RevId: 731115584

Author: dsharletg

bench/qs8-qc8w-gemm-fp32.cc

@@ -19,6 +19,97 @@
 #include "src/xnnpack/packw.h"
 
 
+#if XNN_ENABLE_RISCV_VECTOR && XNN_ARCH_RISCV
+  static void qs8_qc8w_gemm_minmax_fp32_ukernel_1x4v__rvv(benchmark::State& state, const char* net) {
+    GEMMBenchmark(state,
+      xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_1x4v__rvv,
+      xnn_init_qs8_qc8w_conv_minmax_fp32_scalar_params,
+      xnn_pack_qs8_gemm_goi_w,
+      /*mr=*/1, /*nr=*/4 * xnn_init_hardware_config()->vlenb / sizeof(int32_t), /*kr=*/1, /*sr=*/1,
+      benchmark::utils::CheckRVV);
+  }
+
+  BENCHMARK_GEMM(qs8_qc8w_gemm_minmax_fp32_ukernel_1x4v__rvv)
+
+  static void qs8_qc8w_gemm_minmax_fp32_ukernel_2x4v__rvv(benchmark::State& state, const char* net) {
+    GEMMBenchmark(state,
+      xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_2x4v__rvv,
+      xnn_init_qs8_qc8w_conv_minmax_fp32_scalar_params,
+      xnn_pack_qs8_gemm_goi_w,
+      /*mr=*/2, /*nr=*/4 * xnn_init_hardware_config()->vlenb / sizeof(int32_t), /*kr=*/1, /*sr=*/1,
+      benchmark::utils::CheckRVV);
+  }
+
+  BENCHMARK_GEMM(qs8_qc8w_gemm_minmax_fp32_ukernel_2x4v__rvv)
+
+  static void qs8_qc8w_gemm_minmax_fp32_ukernel_3x4v__rvv(benchmark::State& state, const char* net) {
+    GEMMBenchmark(state,
+      xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_3x4v__rvv,
+      xnn_init_qs8_qc8w_conv_minmax_fp32_scalar_params,
+      xnn_pack_qs8_gemm_goi_w,
+      /*mr=*/3, /*nr=*/4 * xnn_init_hardware_config()->vlenb / sizeof(int32_t), /*kr=*/1, /*sr=*/1,
+      benchmark::utils::CheckRVV);
+  }
+
+  BENCHMARK_GEMM(qs8_qc8w_gemm_minmax_fp32_ukernel_3x4v__rvv)
+
+  static void qs8_qc8w_gemm_minmax_fp32_ukernel_4x2v__rvv(benchmark::State& state, const char* net) {
+    GEMMBenchmark(state,
+      xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_4x2v__rvv,
+      xnn_init_qs8_qc8w_conv_minmax_fp32_scalar_params,
+      xnn_pack_qs8_gemm_goi_w,
+      /*mr=*/4, /*nr=*/2 * xnn_init_hardware_config()->vlenb / sizeof(int32_t), /*kr=*/1, /*sr=*/1,
+      benchmark::utils::CheckRVV);
+  }
+
+  BENCHMARK_GEMM(qs8_qc8w_gemm_minmax_fp32_ukernel_4x2v__rvv)
+
+  static void qs8_qc8w_gemm_minmax_fp32_ukernel_5x4v__rvv(benchmark::State& state, const char* net) {
+    GEMMBenchmark(state,
+      xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_5x4v__rvv,
+      xnn_init_qs8_qc8w_conv_minmax_fp32_scalar_params,
+      xnn_pack_qs8_gemm_goi_w,
+      /*mr=*/5, /*nr=*/4 * xnn_init_hardware_config()->vlenb / sizeof(int32_t), /*kr=*/1, /*sr=*/1,
+      benchmark::utils::CheckRVV);
+  }
+
+  BENCHMARK_GEMM(qs8_qc8w_gemm_minmax_fp32_ukernel_5x4v__rvv)
+
+  static void qs8_qc8w_gemm_minmax_fp32_ukernel_6x4v__rvv(benchmark::State& state, const char* net) {
+    GEMMBenchmark(state,
+      xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_6x4v__rvv,
+      xnn_init_qs8_qc8w_conv_minmax_fp32_scalar_params,
+      xnn_pack_qs8_gemm_goi_w,
+      /*mr=*/6, /*nr=*/4 * xnn_init_hardware_config()->vlenb / sizeof(int32_t), /*kr=*/1, /*sr=*/1,
+      benchmark::utils::CheckRVV);
+  }
+
+  BENCHMARK_GEMM(qs8_qc8w_gemm_minmax_fp32_ukernel_6x4v__rvv)
+
+  static void qs8_qc8w_gemm_minmax_fp32_ukernel_7x4v__rvv(benchmark::State& state, const char* net) {
+    GEMMBenchmark(state,
+      xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_7x4v__rvv,
+      xnn_init_qs8_qc8w_conv_minmax_fp32_scalar_params,
+      xnn_pack_qs8_gemm_goi_w,
+      /*mr=*/7, /*nr=*/4 * xnn_init_hardware_config()->vlenb / sizeof(int32_t), /*kr=*/1, /*sr=*/1,
+      benchmark::utils::CheckRVV);
+  }
+
+  BENCHMARK_GEMM(qs8_qc8w_gemm_minmax_fp32_ukernel_7x4v__rvv)
+
+  static void qs8_qc8w_gemm_minmax_fp32_ukernel_8x4v__rvv(benchmark::State& state, const char* net) {
+    GEMMBenchmark(state,
+      xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_8x4v__rvv,
+      xnn_init_qs8_qc8w_conv_minmax_fp32_scalar_params,
+      xnn_pack_qs8_gemm_goi_w,
+      /*mr=*/8, /*nr=*/4 * xnn_init_hardware_config()->vlenb / sizeof(int32_t), /*kr=*/1, /*sr=*/1,
+      benchmark::utils::CheckRVV);
+  }
+
+  BENCHMARK_GEMM(qs8_qc8w_gemm_minmax_fp32_ukernel_8x4v__rvv)
+#endif  // XNN_ENABLE_RISCV_VECTOR && XNN_ARCH_RISCV
+
+
 #if XNN_ARCH_WASMSIMD || XNN_ARCH_WASMRELAXEDSIMD
   static void qs8_qc8w_gemm_minmax_fp32_ukernel_1x4c2__wasmsimd_dot16x2_ld64(benchmark::State& state, const char* net) {
     GEMMBenchmark(state,

test/qs8-qc8w-gemm-minmax-fp32-2.cc

@@ -267,6 +267,244 @@ std::vector<GemmTestParams> CreateTests1(
   return gemm_tests;
 }
 
+#if XNN_ENABLE_RISCV_VECTOR && XNN_ARCH_RISCV
+  std::vector<GemmTestParams> CreateTests2(
+      size_t k_block, size_t adj_k_block,
+      size_t mr, size_t nr, size_t kr, size_t sr,
+      bool is_igemm,
+      bool unsigned_inputs,
+      uint8_t planes,
+      std::function<void(GemmMicrokernelTester& tester)> test_func,
+      std::function<void()> isa_check = nullptr) {
+    std::string kbs = std::to_string(k_block);
+    std::string kb2s = std::to_string(k_block * 2);
+    std::string akbs = std::to_string(adj_k_block);
+    nr = nr * xnn_init_hardware_config()->vlenb / sizeof(int32_t);
+    std::string nrs = std::to_string(nr);
+
+    const GemmMicrokernelTester tester = GemmMicrokernelTester()
+        .mr(mr).nr(nr).kr(kr).sr(sr).unsigned_inputs(unsigned_inputs).planes(planes);
+
+    std::vector<GemmTestParams> gemm_tests;
+    gemm_tests.reserve(42);
+
+    gemm_tests.push_back(GemmTestParams(
+        "k_eq_" + kbs,
+        tester.clone()
+            .m(mr).n(nr).k(k_block)
+        , test_func, isa_check));
+    if (!is_igemm) {
+      gemm_tests.push_back(GemmTestParams(
+          "k_eq_" + kbs + "_strided_a",
+          tester.clone()
+              .m(mr).n(nr).k(k_block)
+              .a_stride(xnnpack::NextPrime(k_block + 1))
+          , test_func, isa_check));
+    }
+    gemm_tests.push_back(GemmTestParams(
+        "k_eq_" + kbs + "_subtile",
+        tester.clone()
+            .k(k_block)
+        , test_func, isa_check)
+        .loop_n(1, nr)
+        .loop_m(1, mr));
+    gemm_tests.push_back(GemmTestParams(
+        "k_eq_" + kbs + "_subtile_m",
+        tester.clone()
+            .n(nr).k(k_block)
+        , test_func, isa_check)
+        .loop_m(1, mr));
+    gemm_tests.push_back(GemmTestParams(
+        "k_eq_" + kbs + "_subtile_n",
+        tester.clone()
+            .m(mr).k(k_block)
+        , test_func, isa_check)
+        .loop_n(1, nr));
+    if (k_block > 1) {
+      gemm_tests.push_back(GemmTestParams(
+          "k_lt_" + akbs,
+          tester.clone()
+              .m(mr).n(nr)
+          , test_func, isa_check)
+          .loop_k(1, adj_k_block - 1));
+      if (!is_igemm) {
+        gemm_tests.push_back(GemmTestParams(
+            "k_lt_" + akbs + "_strided_a",
+            tester.clone()
+                .m(mr).n(nr)
+                .a_stride(xnnpack::NextPrime(adj_k_block + 1))
+            , test_func, isa_check)
+            .loop_k(1, adj_k_block - 1));
+      }
+      gemm_tests.push_back(GemmTestParams(
+          "k_lt_" + akbs + "_subtile",
+          tester.clone()
+          , test_func, isa_check)
+          .loop_k(1, adj_k_block - 1)
+          .loop_n(1, nr)
+          .loop_m(1, mr));
+    }
+    gemm_tests.push_back(GemmTestParams(
+        "k_gt_" + akbs,
+        tester.clone()
+            .m(mr).n(nr)
+        , test_func, isa_check)
+        .loop_k(adj_k_block + 1, adj_k_block * 2 - 1, k_block));
+    if (is_igemm) {
+      gemm_tests.push_back(GemmTestParams(
+          "k_gt_" + akbs + "_strided_a",
+          tester.clone()
+              .m(mr).n(nr)
+              .a_stride(xnnpack::NextPrime(adj_k_block * 2 + 1))
+        , test_func, isa_check)
+        .loop_k(adj_k_block + 1, adj_k_block * 2 - 1, k_block));
+    }
+    gemm_tests.push_back(GemmTestParams(
+        "k_gt_" + akbs + "_subtile",
+        tester.clone()
+        , test_func, isa_check)
+        .loop_k(adj_k_block + 1, adj_k_block * 2 - 1, k_block)
+        .loop_n(1, nr)
+        .loop_m(1, mr));
+    if (k_block > 1) {
+      gemm_tests.push_back(GemmTestParams(
+          "k_div_" + kbs,
+          tester.clone()
+              .m(mr).n(nr)
+          , test_func, isa_check)
+          .loop_k(adj_k_block + k_block, k_block * 5, k_block));
+      if (is_igemm) {
+        gemm_tests.push_back(GemmTestParams(
+            "k_div_" + kbs + "_strided_a",
+            tester.clone()
+                .m(mr).n(nr)
+                .a_stride(xnnpack::NextPrime(k_block * 3 + 1))
+            , test_func, isa_check)
+            .loop_k(adj_k_block + k_block, k_block * 3, k_block));
+      }
+      gemm_tests.push_back(GemmTestParams(
+          "k_div_" + kbs + "_subtile",
+          tester.clone()
+          , test_func, isa_check)
+          .loop_k(adj_k_block + k_block, k_block * 5, k_block)
+          .loop_n(1, nr)
+          .loop_m(1, mr));
+    }
+    gemm_tests.push_back(GemmTestParams(
+        "n_gt_" + nrs,
+        tester.clone()
+            .m(mr)
+        , test_func, isa_check)
+        .loop_n(nr + 1, nr * 2 - 1, 4)
+        .loop_k(1, k_block * 3, k_block + 1));
+    if (!is_igemm) {
+      gemm_tests.push_back(GemmTestParams(
+          "n_gt_" + nrs + "_strided_a",
+          tester.clone()
+              .m(mr)
+              .a_stride(xnnpack::NextPrime(k_block * 3 + 1))
+          , test_func, isa_check)
+          .loop_n(nr + 1, nr * 2 - 1, 4)
+          .loop_k(1, k_block * 3, k_block));
+    }
+    gemm_tests.push_back(GemmTestParams(
+        "n_gt_" + nrs + "_subtile",
+        tester.clone()
+        , test_func, isa_check)
+        .loop_n(nr + 1, nr * 2 - 1, 4)
+        .loop_k(1, k_block * 3, k_block + 1)
+        .loop_m(1, mr));
+    gemm_tests.push_back(GemmTestParams(
+        "n_div_" + nrs,
+        tester.clone()
+            .m(mr)
+        , test_func, isa_check)
+        .loop_n(nr * 2, nr * 3, nr)
+        .loop_k(1, k_block * 3, k_block + 1));
+    if (!is_igemm) {
+      gemm_tests.push_back(GemmTestParams(
+          "n_div_" + nrs + "_strided_a",
+          tester.clone()
+              .m(mr)
+              .a_stride(xnnpack::NextPrime(k_block * 3 + 1))
+          , test_func, isa_check)
+          .loop_n(nr * 2, nr * 3, nr)
+          .loop_k(1, k_block * 3, k_block));
+    }
+    gemm_tests.push_back(GemmTestParams(
+        "n_div_" + nrs + "_subtile",
+        tester.clone()
+        , test_func, isa_check)
+        .loop_n(nr * 2, nr * 3, nr)
+        .loop_k(1, k_block * 3, k_block + 1)
+        .loop_m(1, mr));
+    if (is_igemm) {
+      gemm_tests.push_back(GemmTestParams(
+          "small_kernel",
+          tester.clone()
+              .m(mr).n(nr).ks(3)
+          , test_func, isa_check)
+          .loop_k(1, k_block * 3, k_block + 1));
+      gemm_tests.push_back(GemmTestParams(
+          "small_kernel_subtile",
+          tester.clone()
+              .ks(3)
+          , test_func, isa_check)
+          .loop_k(1, k_block * 3, k_block + 1)
+          .loop_n(1, nr)
+          .loop_m(1, mr));
+      gemm_tests.push_back(GemmTestParams(
+          "n_gt_" + nrs + "_small_kernel",
+          tester.clone()
+              .m(mr).ks(3)
+          , test_func, isa_check)
+          .loop_n(nr + 1, nr * 2 - 1, 4)
+          .loop_k(1, k_block * 3, k_block + 1));
+      gemm_tests.push_back(GemmTestParams(
+          "n_div_" + nrs + "_small_kernel",
+          tester.clone()
+              .m(mr).ks(3)
+          , test_func, isa_check)
+          .loop_n(nr * 2, nr * 3, nr)
+          .loop_k(1, k_block * 3, k_block + 1));
+    }
+    gemm_tests.push_back(GemmTestParams(
+        "strided_cm_subtile",
+        tester.clone()
+            .mr(mr).nr(nr).kr(kr).sr(sr)
+            .cm_stride(xnnpack::NextPrime(nr + 1))
+        , test_func, isa_check)
+        .loop_k(1, k_block * 3, k_block + 1)
+        .loop_n(1, nr)
+        .loop_m(1, mr));
+    if (is_igemm) {
+      gemm_tests.push_back(GemmTestParams(
+          "a_offset",
+          tester.clone()
+              .m(mr).n(nr).ks(3)
+              .a_offset(xnnpack::NextPrime(mr * k_block * 3 + 1))
+          , test_func, isa_check)
+          .loop_k(1, k_block * 3, k_block + 1));
+      gemm_tests.push_back(GemmTestParams(
+          "zero",
+          tester.clone()
+              .m(mr).n(nr).ks(3)
+              .a_offset(xnnpack::NextPrime(mr * k_block * 3 + 1))
+          , test_func, isa_check)
+          .loop_k(1, k_block * 3, k_block + 1)
+          .loop_zi(0, mr - 1));
+    }
+    gemm_tests.push_back(GemmTestParams(
+        "strided_cm",
+        tester.clone()
+            .m(mr).n(nr).k(k_block)
+            .cm_stride(xnnpack::NextPrime(nr + 1))
+        , test_func, isa_check));
+
+    return gemm_tests;
+  }
+#endif  // XNN_ENABLE_RISCV_VECTOR && XNN_ARCH_RISCV
+
 }  // namespace
 
 
@@ -3010,3 +3248,28 @@ INSTANTIATE_TEST_SUITE_P(
       return info.param.test_name;
     });
 
+
+#if XNN_ENABLE_RISCV_VECTOR && XNN_ARCH_RISCV
+  INSTANTIATE_TEST_SUITE_P(
+      QS8_QC8W_GEMM_MINMAX_FP32_1X4V__RVV, GemmTest,
+      testing::ValuesIn(CreateTests2(
+          /*k_block=*/1,
+          /*adj_k_block=*/1,
+          /*mr=*/1, /*nr=*/4, /*kr=*/1, /*sr=*/1,
+          /*is_igemm=*/false,
+          /*unsigned_inputs=*/false,
+          /*planes=*/1,
+          [](GemmMicrokernelTester& tester) {
+            tester.Test(xnn_qs8_qc8w_gemm_minmax_fp32_ukernel_1x4v__rvv,
+                        xnn_init_qs8_qc8w_conv_minmax_fp32_scalar_params,
+                        xnn_pack_qs8_gemm_goi_w,
+                        xnn_qs8_requantize_fp32);
+          },
+          []() {
+            TEST_REQUIRES_RISCV_VECTOR;
+          })),
+      [](const testing::TestParamInfo<GemmTest::ParamType>& info) {
+        return info.param.test_name;
+      });
+#endif  // XNN_ENABLE_RISCV_VECTOR && XNN_ARCH_RISCV
+