Fix QS8_QC4W benchmark generator

- output to qs8-qc4w-gemm-fp32.cc instead of qs8-qc8w-gemm-fp32.cc

PiperOrigin-RevId: 785579343

Author: fbarchard

bench/BUILD.bazel

@@ -153,6 +153,7 @@ xnnpack_cxx_library(
     "qd8_f32_qc8w_gemm",
     "qd8_f16_qc4w_gemm",
     "qd8_f32_qc4w_gemm",
+    "qs8_qc4w_gemm_fp32",
     "qs8_qc8w_gemm_fp32",
     "qu8_gemm_fp32",
     "qu8_gemm_rndnu",

bench/CMakeLists.txt

@@ -85,6 +85,7 @@ SET(MICROKERNEL_BENCHMARKS
     qp8-f32-qb4w-gemm
     qs8-dwconv
     qs8-gemm
+    qs8-qc4w-gemm-fp32
     qs8-qc8w-gemm-fp32
     qu8-gemm
     qu8-gemm-fp32

bench/gemm-benchmark.cc

@@ -203,6 +203,91 @@ void GEMMBenchmark(benchmark::State& state,
                          benchmark::Counter::kIsRate);
 }
 
+void GEMMBenchmark(benchmark::State& state,
+                   xnn_qs8_qc4w_gemm_minmax_ukernel_fn gemm,
+                   xnn_init_qs8_qc8w_conv_minmax_params_fn init_params,
+                   xnn_pack_qs8_qc4w_gemm_fn pack, size_t mr, size_t nr, size_t kr,
+                   size_t sr, uint64_t arch_flags) {
+  if (!benchmark::utils::CheckArchFlags(state, arch_flags)) {
+    return;
+  }
+
+  const size_t mc = state.range(0);
+  const size_t nc = state.range(1);
+  const size_t kc = state.range(2);
+
+  const size_t nc_stride = benchmark::utils::RoundUp(nc, nr);
+  const size_t kc_stride = benchmark::utils::RoundUp(kc, kr * sr) / 2;
+
+  std::random_device random_device;
+  auto rng = std::mt19937(random_device());
+  auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000),
+                          std::ref(rng));
+
+  xnnpack::Buffer<int8_t> a(mc * kc, xnnpack::XnnExtraBytes);
+  xnnpack::fill_uniform_random_bits(a.data(), a.size(), rng);
+  xnnpack::Buffer<uint8_t> k(nc * kc / 2);
+  xnnpack::fill_uniform_random_bits(k.data(), k.size(), rng);
+  xnnpack::Buffer<int32_t> b(nc);
+  std::generate(b.begin(), b.end(), std::ref(i32rng));
+
+  const size_t w_size = nc_stride * (sizeof(float) + sizeof(int32_t)) +
+                        kc_stride * nc_stride;
+  const size_t c_elements = mc * nc;
+  const size_t num_buffers = 1 + benchmark::utils::DivideRoundUp<size_t>(
+                                     benchmark::utils::GetMaxCacheSize(),
+                                     w_size + c_elements * sizeof(int8_t));
+
+  xnnpack::Buffer<char, XNN_ALLOCATION_ALIGNMENT> w(w_size * num_buffers);
+
+  const xnn_qs8_qc4w_packing_params packing_params = {int8_t(127 - 0x80)};
+  pack(/*g=*/1, nc, kc, nr, kr, sr, k.data(), b.data(), /*scale=*/nullptr,
+       w.data(), nr * sizeof(float), &packing_params);
+
+  xnnpack::Buffer<int8_t> c(c_elements * num_buffers);
+
+  union xnn_qs8_qc8w_conv_minmax_params quantization_params;
+  init_params(&quantization_params,
+              /*output_zero_point=*/127,
+              /*output_min=*/-127,
+              /*output_max=*/126);
+
+  size_t buffer_index = 0;
+  for (auto _ : state) {
+    // Use circular buffers (exceeding cache size) and prefetch to control cache
+    // state:
+    // - A is always in L1 cache (if fits, otherwise L2, L3, etc)
+    // - W is not in cache (for any cache level)
+    // - C is not in cache (for any cache level)
+    state.PauseTiming();
+    benchmark::utils::PrefetchToL1(a.data(), a.size() * sizeof(int8_t));
+    buffer_index = (buffer_index + 1) % num_buffers;
+    state.ResumeTiming();
+
+    for (uint32_t m = 0; m < mc; m += mr) {
+      const uint32_t mb = min(mc - m, mr);
+      for (uint32_t n = 0; n < nc; n += nr) {
+        const uint32_t nb = min(nc - n, nr);
+        gemm(mb, nb, kc * sizeof(int8_t), a.data() + m * kc,
+             kc * sizeof(int8_t),
+             w.data() + w_size * buffer_index +
+                 n * (kc_stride + sizeof(int32_t)),
+             c.data() + (mc * buffer_index + m) * nc + n, nc * sizeof(int8_t),
+             nr * sizeof(int8_t), &quantization_params);
+      }
+    }
+  }
+
+  const uint64_t cpu_frequency = benchmark::utils::GetCurrentCpuFrequency();
+  if (cpu_frequency != 0) {
+    state.counters["cpufreq"] = cpu_frequency;
+  }
+
+  state.counters["OPS"] =
+      benchmark::Counter(uint64_t(state.iterations()) * 2 * mc * nc * kc,
+                         benchmark::Counter::kIsRate);
+}
+
 void GEMMBenchmark(benchmark::State& state,
                    xnn_qd8_f16_qc8w_gemm_ukernel_fn gemm,
                    xnn_init_f16_minmax_params_fn init_params,

bench/gemm-benchmark.h

@@ -26,6 +26,13 @@ void GEMMBenchmark(benchmark::State& state, xnn_qs8_gemm_minmax_ukernel_fn gemm,
                    size_t sr,
                    uint64_t arch_flags = 0);
 
+void GEMMBenchmark(benchmark::State& state,
+                   xnn_qs8_qc4w_gemm_minmax_ukernel_fn gemm,
+                   xnn_init_qs8_qc8w_conv_minmax_params_fn init_params,
+                   xnn_pack_qs8_qc4w_gemm_fn pack, size_t mr, size_t nr, size_t kr,
+                   size_t sr,
+                   uint64_t arch_flags = 0);
+
 void GEMMBenchmark(benchmark::State& state,
                    xnn_qs8_qc8w_gemm_minmax_ukernel_fn gemm,
                    xnn_init_qs8_qc8w_conv_minmax_params_fn init_params,