- Delete all gemm kernel in ncnn as they are not using gemm but gemv, which hurts the performance of large batch size

- Update kleidiai's gemm to use both GEMV and GEMM: for small batch size (less than 4 or 8) use GEMV for large batch size use GEMM

definitions/gemm/gemm_fp32_n1000_k1280.json

@@ -1,50 +0,0 @@
-{
-  "name": "gemm_fp32_n1000_k1280",
-  "op_type": "gemm",
-  "description": "fc N=1000 K=1280",
-  "tags": [
-    "status:active",
-    "model:mobilenetv3-large",
-    "baseline-solution:ncnn"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 1000
-    },
-    "K": {
-      "type": "const",
-      "value": 1280
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "float32"
-    },
-    "B": {
-      "shape": [
-        "N",
-        "K"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\ndef run(A, B):\n    return A @ B.T\n"
-}

definitions/gemm/gemm_fp32_n1000_k2048.json

@@ -1,50 +0,0 @@
-{
-  "name": "gemm_fp32_n1000_k2048",
-  "op_type": "gemm",
-  "description": "fc N=1000 K=2048",
-  "tags": [
-    "status:active",
-    "model:resnet50",
-    "baseline-solution:ncnn"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 1000
-    },
-    "K": {
-      "type": "const",
-      "value": 2048
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "float32"
-    },
-    "B": {
-      "shape": [
-        "N",
-        "K"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\ndef run(A, B):\n    return A @ B.T\n"
-}

definitions/gemm/gemm_fp32_n1280_k960.json

@@ -1,50 +0,0 @@
-{
-  "name": "gemm_fp32_n1280_k960",
-  "op_type": "gemm",
-  "description": "fc N=1280 K=960",
-  "tags": [
-    "status:active",
-    "model:mobilenetv3-large",
-    "baseline-solution:ncnn"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 1280
-    },
-    "K": {
-      "type": "const",
-      "value": 960
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "float32"
-    },
-    "B": {
-      "shape": [
-        "N",
-        "K"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\ndef run(A, B):\n    return A @ B.T\n"
-}

definitions/gemm/gemm_fp32_n29_k800.json

@@ -1,50 +0,0 @@
-{
-  "name": "gemm_fp32_n29_k800",
-  "op_type": "gemm",
-  "description": "DS2 output FC N=29 K=800",
-  "tags": [
-    "status:active",
-    "model:deepspeech2",
-    "baseline-solution:ncnn"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 29
-    },
-    "K": {
-      "type": "const",
-      "value": 800
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "float32"
-    },
-    "B": {
-      "shape": [
-        "N",
-        "K"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\ndef run(A, B):\n    return A @ B.T\n"
-}

definitions/gemm/gemm_w8a8ch_n1000_k1280.json

@@ -1,60 +0,0 @@
-{
-  "name": "gemm_w8a8ch_n1000_k1280",
-  "op_type": "gemm",
-  "description": "fc N=1000 K=1280",
-  "tags": [
-    "status:active",
-    "model:mobilenetv3-large",
-    "baseline-solution:ncnn"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 1000
-    },
-    "K": {
-      "type": "const",
-      "value": 1280
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "B": {
-      "shape": [
-        "N",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "input_scale": {
-      "shape": null,
-      "dtype": "float32"
-    },
-    "weight_scales": {
-      "shape": [
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\ndef run(A, B, input_scale, weight_scales):\n    A_f = A.astype(np.float32) * np.float32(input_scale)\n    B_f = B.astype(np.float32) * weight_scales.astype(np.float32)[:, np.newaxis]\n    return (A_f @ B_f.T).astype(np.float32)\n"
-}

definitions/gemm/gemm_w8a8ch_n1000_k2048.json

@@ -1,60 +0,0 @@
-{
-  "name": "gemm_w8a8ch_n1000_k2048",
-  "op_type": "gemm",
-  "description": "fc N=1000 K=2048",
-  "tags": [
-    "status:active",
-    "model:resnet50",
-    "baseline-solution:ncnn"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 1000
-    },
-    "K": {
-      "type": "const",
-      "value": 2048
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "B": {
-      "shape": [
-        "N",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "input_scale": {
-      "shape": null,
-      "dtype": "float32"
-    },
-    "weight_scales": {
-      "shape": [
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\ndef run(A, B, input_scale, weight_scales):\n    A_f = A.astype(np.float32) * np.float32(input_scale)\n    B_f = B.astype(np.float32) * weight_scales.astype(np.float32)[:, np.newaxis]\n    return (A_f @ B_f.T).astype(np.float32)\n"
-}

definitions/gemm/gemm_w8a8ch_n1280_k960.json

@@ -1,60 +0,0 @@
-{
-  "name": "gemm_w8a8ch_n1280_k960",
-  "op_type": "gemm",
-  "description": "fc N=1280 K=960",
-  "tags": [
-    "status:active",
-    "model:mobilenetv3-large",
-    "baseline-solution:ncnn"
-  ],
-  "axes": {
-    "M": {
-      "type": "var"
-    },
-    "N": {
-      "type": "const",
-      "value": 1280
-    },
-    "K": {
-      "type": "const",
-      "value": 960
-    }
-  },
-  "inputs": {
-    "A": {
-      "shape": [
-        "M",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "B": {
-      "shape": [
-        "N",
-        "K"
-      ],
-      "dtype": "int8"
-    },
-    "input_scale": {
-      "shape": null,
-      "dtype": "float32"
-    },
-    "weight_scales": {
-      "shape": [
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "outputs": {
-    "C": {
-      "shape": [
-        "M",
-        "N"
-      ],
-      "dtype": "float32"
-    }
-  },
-  "constraints": [],
-  "reference": "import numpy as np\ndef run(A, B, input_scale, weight_scales):\n    A_f = A.astype(np.float32) * np.float32(input_scale)\n    B_f = B.astype(np.float32) * weight_scales.astype(np.float32)[:, np.newaxis]\n    return (A_f @ B_f.T).astype(np.float32)\n"
-}

solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_f16_n512_k512.json

@@ -3,7 +3,7 @@
   "definition": "gemm_f16_n512_k512",
   "dataset": "kleidiai",
   "author": "baseline-kleidiai-arm",
-  "description": "Real ARM KleidiAI SME2 pure f16 GEMM kernel (kai_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot, unpacked LHS) -- hand-vendored .c/.h/.S sources + custom binding.cpp against gemm_f16_n512_k512's raw ABI. Requires SME2 (mac-m4.metal only).",
+  "description": "Arm KleidiAI f16 SME2 GEMM: DISPATCHES between two real kernels by M. M<8 uses kai_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot (GEMV, m_step=1, unpacked LHS, looped once per row -- this repo's original baseline for this definition). M>=8 uses kai_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa (genuine multi-row SME2 GEMM via the mopa engine, called ONCE for the whole M through a trivial k_chunk_count=1 indirection table -- this session's earlier GEMM-only replacement). 8 is picked because the mopa kernel's own m_step on Apple M4 is mr(2)*(512-bit streaming VL/kr(2))=32, so its latency is roughly FLAT for any M<32 while the GEMV kernel's latency scales with M; measured crossover is between M=4 and M=8. Each path keeps its OWN independent weight-content cache (the two kernels' RHS pack functions produce different packed formats), so only the path actually taken for a given call touches its cache -- no double work. Verified on Apple M4: all 13 workloads PASSED against the real reference; M=1 is 69% faster and M=4 is 11% faster than the GEMM-only binding this replaces, M>=8 is within measurement noise of it (both paths converge to the identical GEMM code there). Both kernels vendored verbatim from github.com/ARM-software/kleidiai.",
   "spec": {
     "language": "cpp",
     "target_hardware": [
@@ -32,6 +32,42 @@
       "path": "kai/kai_common_sme_asm.S",
       "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n    #define KAI_ASM_GLOBAL(name) GLOBAL name\n    #define KAI_ASM_FUNCTION_TYPE(name)\n    #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n    #define KAI_ASM_FUNCTION_END(name) ENDP\n    #define KAI_ASM_FUNCTION_USE(name) name\n\n    #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n    #define KAI_ASM_ALIGN\n    #define KAI_ASM_LABEL(name) name\n    #define KAI_ASM_INST(hex) DCD hex\n    #define KAI_ASM_END END\n#else\n    #if defined(__APPLE__)\n        #define KAI_ASM_GLOBAL(name) .globl _##name\n        #define KAI_ASM_FUNCTION_TYPE(name)\n        #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n        #define KAI_ASM_FUNCTION_END(name)\n        #define KAI_ASM_FUNCTION_USE(name) _##name\n    #else\n        #define KAI_ASM_GLOBAL(name) .global name\n        #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n        #define KAI_ASM_FUNCTION_LABEL(name) name:\n        #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n        #define KAI_ASM_FUNCTION_USE(name) name\n    #endif\n\n    #define KAI_ASM_CODE(name) .text\n    #define KAI_ASM_ALIGN .p2align 4,,11\n    #define KAI_ASM_LABEL(name) name:\n    #define KAI_ASM_INST(hex) .inst hex\n    #define KAI_ASM_END\n#endif\n\n    KAI_ASM_CODE(kai_common)\n    KAI_ASM_ALIGN\n\n    KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n    KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n    stp fp, lr, [sp, #-16]!\n    mov fp, sp\n    mrs x9, TPIDR2_EL0\n    cbz x9, leave\n    bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n    msr TPIDR2_EL0, xzr\nleave:\n    ldp fp, lr, [sp], #16\n#endif\n    ret\n    KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n    KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n    ret\n    KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n    KAI_ASM_END\n"
     },
+    {
+      "path": "kai_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa.h",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include <stddef.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif  // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_lhs_imatmul_pack_x16p2vlx2_x16p_sme to pack the LHS matrix.\n/// -# kai_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme to pack the RHS matrix.\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(void);\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(void);\n\n/// Gets the offset in bytes to the data element in the packed LHS matrix buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix. Must be a multiple of `m_step`.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n    size_t m_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the offset in bytes to the data element in the packed RHS matrix buffer.\n///\n/// @param[in] n_idx Column index in the unpacked RHS matrix. Must be a multiple of `n_step`.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n    size_t n_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the offset in bytes to the data element in the destination matrix buffer.\n///\n/// @param[in] m_idx Row index. Must be a multiple of `m_step`.\n/// @param[in] n_idx Column index. Must be a multiple of `n_step`.\n/// @param[in] dst_stride_row Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_dst_offset_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n    size_t m_idx, size_t n_idx, size_t dst_stride_row);\n\n/// Gets the size in bytes of the destination matrix buffer.\n///\n/// @param[in] m Number of rows.\n/// @param[in] n Number of columns.\n///\n/// @return The size in bytes of the destination matrix buffer.\nsize_t kai_get_dst_size_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(size_t m, size_t n);\n\n/// Runs the matrix multiplication microkernel followed by a clamp operation.\n///\n/// The pointer of each buffers (packed LHS, packed RHS and output) needs to be added with offset\n/// calculated using the following functions:\n///\n///   * Packed LHS: @ref kai_get_lhs_packed_offset_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa.\n///   * Packed RHS: @ref kai_get_rhs_packed_offset_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa.\n///   * Output: @ref kai_get_dst_offset_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa.\n///\n/// @param[in] m Number of output rows to be computed.\n/// @param[in] n Number of output columns to be computed.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n/// @param[in] lhs_packed Packed LHS matrix buffer.\n/// @param[in] rhs_packed Packed RHS matrix buffer.\n/// @param[out] dst Output matrix buffer.\n/// @param[in] dst_stride_row Row stride in bytes of the output matrix.\n/// @param[in] clamp_min Minimum value to clamp the final result.\n/// @param[in] clamp_max Maximum value to clamp the final result.\n///\n/// @note Clamp minimum and maximum values are cast internally to the destination type before clamping the computed\n/// values.\n///\nvoid kai_run_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n    size_t m, size_t n, size_t k_chunk_count, size_t k_chunk_length, const void* lhs_packed, const void* rhs_packed,\n    void* dst, size_t dst_stride_row, float clamp_min, float clamp_max);\n\n#ifdef __cplusplus\n}  // extern \"C\"\n#endif  // __cplusplus\n"
+    },
+    {
+      "path": "kai_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa.c",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else  // Architectural features check.\n#include \"kai_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa.h\"\n\n#include <stddef.h>\n#include <stdint.h>\n\n#include \"kai/kai_common.h\"\n\ntypedef struct {\n    const void* A;\n    const void* B;\n    void* C;\n    uint64_t ldcb;\n    uint64_t M;\n    uint64_t N;\n    uint64_t K;\n    uint16_t min;\n    uint16_t max;\n    void* accumulator_buffer;\n    uint64_t flags;\n} KernelArgs;\n\nstatic const size_t kai_mr = 2;\nstatic const size_t kai_nr = 2;\nstatic const size_t kai_kr = 2;\n\nvoid kai_kernel_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(KernelArgs* args);\nuint16_t kai_f16_from_float_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(float value);\n\n// Returns a constant value specific to this kernel that's relative to vector length\nstatic size_t kai_get_kernel_vec_length_constant(void) {\n    const size_t kernel_vec_length_constant = kai_get_sme_vector_length_u16() / kai_kr;\n    return kernel_vec_length_constant;\n}\n\nsize_t kai_get_m_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(void) {\n    return kai_mr * kai_get_kernel_vec_length_constant();\n}\n\nsize_t kai_get_n_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(void) {\n    return kai_nr * kai_get_kernel_vec_length_constant();\n}\n\nsize_t kai_get_lhs_packed_offset_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n    size_t m_idx, size_t k_chunk_count, size_t k_chunk_length) {\n    KAI_ASSUME(m_idx % kai_get_m_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa() == 0);\n    return m_idx * k_chunk_count * kai_roundup(k_chunk_length, kai_kr) * sizeof(uint16_t);\n}\n\nstatic size_t kai_get_rhs_packed_stride_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n    size_t k_chunk_count, size_t k_chunk_length) {\n    return kai_get_n_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa() *\n        (sizeof(uint16_t) + k_chunk_count * kai_roundup(k_chunk_length, kai_kr) * sizeof(uint16_t));\n}\n\nsize_t kai_get_rhs_packed_offset_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n    size_t n_idx, size_t k_chunk_count, size_t k_chunk_length) {\n    KAI_ASSUME(n_idx % kai_get_n_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa() == 0);\n    const size_t block_idx = n_idx / kai_get_n_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa();\n    return block_idx *\n        kai_get_rhs_packed_stride_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n               k_chunk_count, k_chunk_length);\n}\n\nsize_t kai_get_dst_offset_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n    size_t m_idx, size_t n_idx, size_t dst_stride_row) {\n    KAI_ASSUME(m_idx % kai_get_m_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa() == 0);\n    KAI_ASSUME(n_idx % kai_get_n_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa() == 0);\n\n    return m_idx * dst_stride_row + n_idx * sizeof(uint16_t);\n}\n\nsize_t kai_get_dst_size_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(size_t m, size_t n) {\n    return m * n * sizeof(uint16_t);\n}\n\nvoid kai_run_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n    size_t m, size_t n, size_t k_chunk_count, size_t k_chunk_length, const void* lhs_packed, const void* rhs_packed,\n    void* dst, size_t dst_stride_row, float clamp_min, float clamp_max) {\n    KernelArgs args;\n\n    args.A = lhs_packed;\n    args.B = rhs_packed;\n    args.C = dst;\n    args.ldcb = dst_stride_row;\n    args.M = m;\n    args.N = n;\n    args.K = k_chunk_count * kai_roundup(k_chunk_length, kai_kr);\n    args.min = kai_f16_from_float_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(clamp_min);\n    args.max = kai_f16_from_float_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(clamp_max);\n    args.accumulator_buffer = NULL;\n    args.flags = 0;\n\n    kai_commit_za();\n\n    kai_kernel_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(&args);\n}\n\n#endif  // Architectural features check.\n"
+    },
+    {
+      "path": "kai_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa_asm.S",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n    #define KAI_ASM_GLOBAL(name) GLOBAL name\n    #define KAI_ASM_FUNCTION_TYPE(name)\n    #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n    #define KAI_ASM_FUNCTION_END(name) ENDP\n\n    #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n    #define KAI_ASM_ALIGN\n    #define KAI_ASM_LABEL(name) name\n    #define KAI_ASM_INST(hex) DCD hex\n    #define KAI_ASM_END END\n#else\n    #if defined(__APPLE__)\n        #define KAI_ASM_GLOBAL(name) .globl _##name\n        #define KAI_ASM_FUNCTION_TYPE(name)\n        #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n        #define KAI_ASM_FUNCTION_END(name)\n    #else\n        #define KAI_ASM_GLOBAL(name) .global name\n        #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n        #define KAI_ASM_FUNCTION_LABEL(name) name:\n        #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n    #endif\n\n    #define KAI_ASM_CODE(name) .text\n    #define KAI_ASM_ALIGN .p2align 4,,11\n    #define KAI_ASM_LABEL(name) name:\n    #define KAI_ASM_INST(hex) .inst hex\n    #define KAI_ASM_END\n#endif\n\n    KAI_ASM_CODE(imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa)\n    KAI_ASM_ALIGN\n\n    KAI_ASM_GLOBAL(kai_kernel_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa)\n    KAI_ASM_GLOBAL(kai_f16_from_float_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_f16_from_float_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_f16_from_float_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa)\n    fcvt h0, s0\n    fmov w0, h0\n    ret\n    KAI_ASM_FUNCTION_END(kai_f16_from_float_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa)\n    stp x20, x21, [sp, -144]!\n    stp x22, x23, [sp, 16]\n    stp x24, x25, [sp, 32]\n    stp x26, x27, [sp, 48]\n    str x28, [sp, 64]\n    stp d8, d9, [sp, 72]\n    stp d10, d11, [sp, 88]\n    stp d12, d13, [sp, 104]\n    stp d14, d15, [sp, 120]\n    KAI_ASM_INST(0xd503477f)  // SMSTART ZA\n    mov x14, #0x0\n    ldr x13, [x0, #0x30]\n    ptrue p1.b\n    KAI_ASM_INST(0x25207810)  // ptrue pn8.b\n    ldr w11, [x0, #0x20]\n    mov x10, #0x0\n    ldr w9, [x0, #0x28]\n    add x13, x13, #0x1\n    ldr x28, [x0, #0x0]\n    lsr x13, x13, #0x1\nKAI_ASM_LABEL(label_1)  // M loop\n    ldr x27, [x0, #0x8]\nKAI_ASM_LABEL(label_2)  // N loop\n    fmov z23.h, #0.0\n    ld1h { z18.h }, p1/Z, [x27]\n    fmov z2.h, #1.0\n    mov x26, x28\n    KAI_ASM_INST(0xc00800ff)  // zero { zad0, zad1, zad2, zad3, zad4, zad5, zad6, zad7 }\n    inch x27, ALL, MUL #2\n    zip1 z14.h, z18.h, z23.h\n    zip2 z3.h, z18.h, z23.h\n    KAI_ASM_INST(0x81ae2440)  // fmopa za0.s, p1/M, p1/M, z2.h, z14.h\n    KAI_ASM_INST(0x81a32441)  // fmopa za1.s, p1/M, p1/M, z2.h, z3.h\n    KAI_ASM_INST(0x81ae2442)  // fmopa za2.s, p1/M, p1/M, z2.h, z14.h\n    KAI_ASM_INST(0x81a32443)  // fmopa za3.s, p1/M, p1/M, z2.h, z3.h\n    lsr x21, x13, #0x2\n    and x20, x13, #0x3\n    cbz x21, label_6\n    subs x21, x21, #0x1\n    KAI_ASM_INST(0xa040a350)  // ld1h { z16.h-z19.h }, pn8.b/Z, [x26]\n    KAI_ASM_INST(0xa041a35c)  // ld1h { z28.h-z31.h }, pn8.b/Z, [x26, #0x4, MUL VL]\n    addvl x26, x26, #8\n    KAI_ASM_INST(0xa040a360)  // ld1h { z0.h-z3.h }, pn8.b/Z, [x27]\n    KAI_ASM_INST(0xa041a368)  // ld1h { z8.h-z11.h }, pn8.b/Z, [x27, #0x4, MUL VL]\n    addvl x27, x27, #8\n    ble label_5\nKAI_ASM_LABEL(label_4)  // K loop\n    KAI_ASM_INST(0x81a02600)  // fmopa za0.s, p1/M, p1/M, z16.h, z0.h\n    subs x21, x21, #0x1\n    KAI_ASM_INST(0x81a12601)  // fmopa za1.s, p1/M, p1/M, z16.h, z1.h\n    KAI_ASM_INST(0x81a02622)  // fmopa za2.s, p1/M, p1/M, z17.h, z0.h\n    KAI_ASM_INST(0x81a12623)  // fmopa za3.s, p1/M, p1/M, z17.h, z1.h\n    KAI_ASM_INST(0x81a22640)  // fmopa za0.s, p1/M, p1/M, z18.h, z2.h\n    KAI_ASM_INST(0x81a32641)  // fmopa za1.s, p1/M, p1/M, z18.h, z3.h\n    KAI_ASM_INST(0x81a22662)  // fmopa za2.s, p1/M, p1/M, z19.h, z2.h\n    KAI_ASM_INST(0x81a32663)  // fmopa za3.s, p1/M, p1/M, z19.h, z3.h\n    KAI_ASM_INST(0xa040a350)  // ld1h { z16.h-z19.h }, pn8.b/Z, [x26]\n    KAI_ASM_INST(0x81a82780)  // fmopa za0.s, p1/M, p1/M, z28.h, z8.h\n    KAI_ASM_INST(0xa040a360)  // ld1h { z0.h-z3.h }, pn8.b/Z, [x27]\n    KAI_ASM_INST(0x81a92781)  // fmopa za1.s, p1/M, p1/M, z28.h, z9.h\n    KAI_ASM_INST(0x81a827a2)  // fmopa za2.s, p1/M, p1/M, z29.h, z8.h\n    KAI_ASM_INST(0x81a927a3)  // fmopa za3.s, p1/M, p1/M, z29.h, z9.h\n    KAI_ASM_INST(0x81aa27c0)  // fmopa za0.s, p1/M, p1/M, z30.h, z10.h\n    KAI_ASM_INST(0x81ab27c1)  // fmopa za1.s, p1/M, p1/M, z30.h, z11.h\n    KAI_ASM_INST(0x81aa27e2)  // fmopa za2.s, p1/M, p1/M, z31.h, z10.h\n    KAI_ASM_INST(0x81ab27e3)  // fmopa za3.s, p1/M, p1/M, z31.h, z11.h\n    KAI_ASM_INST(0xa041a35c)  // ld1h { z28.h-z31.h }, pn8.b/Z, [x26, #0x4, MUL VL]\n    addvl x26, x26, #8\n    KAI_ASM_INST(0xa041a368)  // ld1h { z8.h-z11.h }, pn8.b/Z, [x27, #0x4, MUL VL]\n    addvl x27, x27, #8\n    bgt label_4\nKAI_ASM_LABEL(label_5)  // K loop tail\n    KAI_ASM_INST(0x81a02600)  // fmopa za0.s, p1/M, p1/M, z16.h, z0.h\n    KAI_ASM_INST(0x81a12601)  // fmopa za1.s, p1/M, p1/M, z16.h, z1.h\n    KAI_ASM_INST(0x81a02622)  // fmopa za2.s, p1/M, p1/M, z17.h, z0.h\n    KAI_ASM_INST(0x81a12623)  // fmopa za3.s, p1/M, p1/M, z17.h, z1.h\n    KAI_ASM_INST(0x81a22640)  // fmopa za0.s, p1/M, p1/M, z18.h, z2.h\n    KAI_ASM_INST(0x81a32641)  // fmopa za1.s, p1/M, p1/M, z18.h, z3.h\n    KAI_ASM_INST(0x81a22662)  // fmopa za2.s, p1/M, p1/M, z19.h, z2.h\n    KAI_ASM_INST(0x81a32663)  // fmopa za3.s, p1/M, p1/M, z19.h, z3.h\n    KAI_ASM_INST(0x81a82780)  // fmopa za0.s, p1/M, p1/M, z28.h, z8.h\n    KAI_ASM_INST(0x81a92781)  // fmopa za1.s, p1/M, p1/M, z28.h, z9.h\n    KAI_ASM_INST(0x81a827a2)  // fmopa za2.s, p1/M, p1/M, z29.h, z8.h\n    KAI_ASM_INST(0x81a927a3)  // fmopa za3.s, p1/M, p1/M, z29.h, z9.h\n    KAI_ASM_INST(0x81aa27c0)  // fmopa za0.s, p1/M, p1/M, z30.h, z10.h\n    KAI_ASM_INST(0x81ab27c1)  // fmopa za1.s, p1/M, p1/M, z30.h, z11.h\n    KAI_ASM_INST(0x81aa27e2)  // fmopa za2.s, p1/M, p1/M, z31.h, z10.h\n    KAI_ASM_INST(0x81ab27e3)  // fmopa za3.s, p1/M, p1/M, z31.h, z11.h\nKAI_ASM_LABEL(label_6)  // K oddments\n    cbz x20, label_8\nKAI_ASM_LABEL(label_7)  // K oddments: Loop\n    KAI_ASM_INST(0xa1402345)  // ld1h { z5.h, z13.h }, pn8.b/Z, [x26]\n    subs x20, x20, #0x1\n    addvl x26, x26, #2\n    KAI_ASM_INST(0xa040236e)  // ld1h { z14.h-z15.h }, pn8.b/Z, [x27]\n    addvl x27, x27, #2\n    KAI_ASM_INST(0x81ae24a0)  // fmopa za0.s, p1/M, p1/M, z5.h, z14.h\n    KAI_ASM_INST(0x81af24a1)  // fmopa za1.s, p1/M, p1/M, z5.h, z15.h\n    KAI_ASM_INST(0x81ae25a2)  // fmopa za2.s, p1/M, p1/M, z13.h, z14.h\n    KAI_ASM_INST(0x81af25a3)  // fmopa za3.s, p1/M, p1/M, z13.h, z15.h\n    bgt label_7\nKAI_ASM_LABEL(label_8)  // K oddments: End\n    ldr x25, [x0, #0x10]\n    sub x24, x11, x14\n    cntw x23, ALL, MUL #2\n    KAI_ASM_INST(0x84dca411)  // ld1rh { z17.h }, p1/Z, [x0, #56]\n    ldr x22, [x0, #0x18]\n    whilelt p0.h, x10, x9\n    cmp x24, x23\n    KAI_ASM_INST(0x84dda410)  // ld1rh { z16.h }, p1/Z, [x0, #58]\n    mov x12, #0x0\n    mov x21, #0x0\n    add x25, x25, x10, LSL #1  // C += n\n    mov x20, #0x2\n    madd x25, x14, x22, x25  // C += m * ldc\n    csel x24, x24, x23, LT\nKAI_ASM_LABEL(label_10)  // Store to output array: Accumulator loop\n    KAI_ASM_INST(0xc006000e)  // mova { z14.b-z15.b }, za0h.b[x12, 0:1]\n    add x12, x12, #0x4\n    cmp x12, x23, LSL #1\n    add x21, x21, #0x1\n    KAI_ASM_INST(0xc120e1c4)  // fcvt z4.h, { z14.s-z15.s }\n    csel x12, x12, x20, LT\n    cmp x21, x24\n    KAI_ASM_INST(0x64702624)  // fclamp z4.h, z17.h, z16.h\n    st1h { z4.h }, p0, [x25]\n    add x25, x25, x22\n    blt label_10\n    incw x10, ALL, MUL #2\n    cmp x10, x9\n    blt label_2\n    incw x14, ALL, MUL #2\n    mov x10, #0x0\n    cmp x14, x11\n    mov x28, x26\n    blt label_1\n    KAI_ASM_INST(0xd503467f)  // SMSTOP\n    ldp x22, x23, [sp, 16]\n    ldp x24, x25, [sp, 32]\n    ldp x26, x27, [sp, 48]\n    ldr x28, [sp, 64]\n    ldp d8, d9, [sp, 72]\n    ldp d10, d11, [sp, 88]\n    ldp d12, d13, [sp, 104]\n    ldp d14, d15, [sp, 120]\n    ldp x20, x21, [sp], 144\n    ret\n    KAI_ASM_FUNCTION_END(kai_kernel_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa)\n\n    KAI_ASM_END\n"
+    },
+    {
+      "path": "kai_lhs_imatmul_pack_x16p2vlx2_x16p_sme.h",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include <stddef.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif  // __cplusplus\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_lhs_imatmul_pack_x16p2vlx2_x16p_sme(void);\n\n/// Gets the offset in bytes to the data element in the packed LHS buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_lhs_imatmul_pack_x16p2vlx2_x16p_sme(\n    size_t m_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the size in bytes of the packed LHS buffer.\n///\n/// @param[in] m Number of rows in the unpacked LHS matrix.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The size in bytes of the packed LHS buffer.\nsize_t kai_get_lhs_packed_size_lhs_imatmul_pack_x16p2vlx2_x16p_sme(\n    size_t m, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Pack the LHS matrix for use with indirect matrix multiplication\n///\n/// @param[in] m Number of rows of the unpacked LHS matrix.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n/// @param[in] lhs_ptrs Pointer to an array of input pointers consisting of\n///            `roundup(m, m_step) * k_chunk_count` pointers. The pointers are\n///            grouped in blocks of `m_step` rows and `k_chunk_count` columns.\n///            Within each block, the pointers are stored in column-major order.\n/// @param[in] lhs_ptr_offset Offset to add to each pointer of the @ref lhs_ptrs\n///            array, excluding zero pointers.\n/// @param[in] pad_ptr Pointer to chunk used for padding. @ref lhs_ptr_offset is\n///            not applied to this pointer when used in @ref lhs_ptrs. This can\n///            be NULL if there is no padding used @ref lhs_ptrs\n/// @param[out] lhs_packed Packed LHS matrix.\nvoid kai_run_lhs_imatmul_pack_x16p2vlx2_x16p_sme(\n    size_t m, size_t k_chunk_count, size_t k_chunk_length, const void* const* lhs_ptrs, size_t lhs_ptr_offset,\n    const void* pad_ptr, void* lhs_packed);\n\n#ifdef __cplusplus\n}  // extern \"C\"\n#endif  // __cplusplus\n"
+    },
+    {
+      "path": "kai_lhs_imatmul_pack_x16p2vlx2_x16p_sme.c",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else  // Architectural features check.\n#include \"kai_lhs_imatmul_pack_x16p2vlx2_x16p_sme.h\"\n\n#include <stddef.h>\n#include <stdint.h>\n\n#include \"kai/kai_common.h\"\n\nenum {\n    MR = 2,\n    KR = 2,\n    MAX_M_STEP = MR * (KAI_SME_VEC_LENGTH_MAX_BYTES / sizeof(uint16_t)) / KR,\n};\n\nvoid kai_kernel_lhs_imatmul_pack_x16p2vlx2_x16p_sme(size_t height, size_t width, const void* in, void* out);\n\nstatic size_t kai_get_mr_lhs_imatmul_pack_x16p2vlx2_x16p_sme(void) {\n    return MR * kai_get_sme_vector_length_u16() / KR;\n}\n\nsize_t kai_get_m_step_lhs_imatmul_pack_x16p2vlx2_x16p_sme(void) {\n    return kai_get_mr_lhs_imatmul_pack_x16p2vlx2_x16p_sme();\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_imatmul_pack_x16p2vlx2_x16p_sme(\n    size_t m_idx, size_t k_chunk_count, size_t k_chunk_length) {\n    KAI_ASSUME(m_idx % kai_get_m_step_lhs_imatmul_pack_x16p2vlx2_x16p_sme() == 0);\n\n    return m_idx * k_chunk_count * kai_roundup(k_chunk_length, KR) * sizeof(uint16_t);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_imatmul_pack_x16p2vlx2_x16p_sme(\n    size_t m, size_t k_chunk_count, size_t k_chunk_length) {\n    const size_t m_end = kai_roundup(m, kai_get_mr_lhs_imatmul_pack_x16p2vlx2_x16p_sme());\n    return kai_get_lhs_packed_offset_lhs_imatmul_pack_x16p2vlx2_x16p_sme(m_end, k_chunk_count, k_chunk_length);\n}\n\nvoid kai_run_lhs_imatmul_pack_x16p2vlx2_x16p_sme(\n    size_t m, size_t k_chunk_count, size_t k_chunk_length, const void* const* lhs_ptrs, size_t lhs_ptr_offset,\n    const void* pad_ptr, void* lhs_packed) {\n    KAI_ASSUME(lhs_ptrs != NULL);\n    KAI_ASSUME(lhs_packed != NULL);\n\n    const size_t m_step = kai_get_mr_lhs_imatmul_pack_x16p2vlx2_x16p_sme();\n    const size_t table_size = kai_roundup(m, m_step) * k_chunk_count;\n    const size_t width = k_chunk_length;\n\n    KAI_ASSERT(m_step <= MAX_M_STEP);\n    const uint8_t* in[MAX_M_STEP];\n\n    uint8_t* out_base = lhs_packed;\n\n    kai_commit_za();\n\n    for (size_t i_m = 0; i_m < m; i_m += m_step) {\n        for (size_t i_k_chunk = 0; i_k_chunk < k_chunk_count; i_k_chunk += 1) {\n            const size_t height = KAI_MIN(m - i_m, m_step);\n            void* out = out_base;\n            out_base += m_step * kai_roundup(k_chunk_length, KR) * sizeof(uint16_t);\n            for (size_t y = 0; y < height; y += 1) {\n                const size_t lhs_ptr_idx = i_m * k_chunk_count + i_k_chunk * m_step + y;\n                KAI_ASSERT(lhs_ptr_idx < table_size);\n                in[y] = lhs_ptrs[lhs_ptr_idx];\n                if (in[y] != pad_ptr) {\n                    uintptr_t in_ptr = (uintptr_t)in[y] + lhs_ptr_offset;\n                    in[y] = (const uint8_t*)in_ptr;  // NOLINT(performance-no-int-to-ptr)\n                }\n            }\n\n            // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion)\n            kai_kernel_lhs_imatmul_pack_x16p2vlx2_x16p_sme(height, width, in, out);\n        }\n    }\n}\n\n#endif  // Architectural features check.\n"
+    },
+    {
+      "path": "kai_lhs_imatmul_pack_x16p2vlx2_x16p_sme_asm.S",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n    #define KAI_ASM_GLOBAL(name) GLOBAL name\n    #define KAI_ASM_FUNCTION_TYPE(name)\n    #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n    #define KAI_ASM_FUNCTION_END(name) ENDP\n\n    #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n    #define KAI_ASM_ALIGN\n    #define KAI_ASM_LABEL(name) name\n    #define KAI_ASM_INST(hex) DCD hex\n    #define KAI_ASM_END END\n#else\n    #if defined(__APPLE__)\n        #define KAI_ASM_GLOBAL(name) .globl _##name\n        #define KAI_ASM_FUNCTION_TYPE(name)\n        #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n        #define KAI_ASM_FUNCTION_END(name)\n    #else\n        #define KAI_ASM_GLOBAL(name) .global name\n        #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n        #define KAI_ASM_FUNCTION_LABEL(name) name:\n        #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n    #endif\n\n    #define KAI_ASM_CODE(name) .text\n    #define KAI_ASM_ALIGN .p2align 4,,11\n    #define KAI_ASM_LABEL(name) name:\n    #define KAI_ASM_INST(hex) .inst hex\n    #define KAI_ASM_END\n#endif\n\n    KAI_ASM_CODE(lhs_imatmul_pack_x16p2vlx2_x16p_sme)\n    KAI_ASM_ALIGN\n\n    KAI_ASM_GLOBAL(kai_kernel_lhs_imatmul_pack_x16p2vlx2_x16p_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_lhs_imatmul_pack_x16p2vlx2_x16p_sme)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_lhs_imatmul_pack_x16p2vlx2_x16p_sme)\n    stp x20, x21, [sp, -144]!\n    stp x22, x23, [sp, 16]\n    stp x24, x25, [sp, 32]\n    stp x26, x27, [sp, 48]\n    str x28, [sp, 64]\n    stp d8, d9, [sp, 72]\n    stp d10, d11, [sp, 88]\n    stp d12, d13, [sp, 104]\n    stp d14, d15, [sp, 120]\n    KAI_ASM_INST(0xd503477f)  // SMSTART ZA\n    mov x12, #0x0\n    cnth x21\n    mov x22, x1\n    inch x22\n    mov x20, x1\n    sub x8, x21, #0x1\n    sub x22, x22, #0x1\n    ands x8, x20, x8\n    cntw x17\n    udiv x22, x22, x21  // n_passes = ceildiv(width, VL<T>)\n    csel x8, x8, x21, NE\n    sub x13, x22, #0x1\n    add x8, x8, #0x1\n    sub x16, x17, #0x2\n    lsl x21, x0, #0x1  // height * 2\n    lsl x20, x17, #0x1\n    mov x11, #0x0\n    mov x10, x2\n    add x9, x2, x17, LSL #3\n    cntw x28, ALL, MUL #2\n    cntw x27, ALL, MUL #3\n    ldr x26, [x10, #0x0]\n    lsr x13, x13, #0x1  // n_loops = (n_passes - 1) / 2\n    and x25, x22, #0x1  // odd_tail = bool(n_passes & 0x1)\n    ldr x24, [x9, #0x0]\n    lsr x8, x8, #0x1\n    ptrue p12.s\n    ldr x23, [x10, #0x8]\n    whilelt p11.h, XZR, x21\n    whilelt p10.h, x20, x21\n    ldr x21, [x9, #0x8]\n    mov x22, x12\n    whilelt p9.h, x11, x1\n    whilelt p8.h, x11, x1\n    add x10, x10, #0x10\n    add x9, x9, #0x10\n    mov x12, #0x0\n    cbz x16, label_2\nKAI_ASM_LABEL(label_1)  // K loop: Charge: Loop\n    KAI_ASM_INST(0x25286163)  // psel p3.h, p8.h/Z, p11.h[w12]\n    KAI_ASM_INST(0x25286142)  // psel p2.h, p8.h/Z, p10.h[w12]\n    KAI_ASM_INST(0x25686161)  // psel p1.h, p8.h/Z, p11.h[w12, #2]\n    KAI_ASM_INST(0x25686140)  // psel p0.h, p8.h/Z, p10.h[w12, #2]\n    KAI_ASM_INST(0xe0560f40)  // ld1h { za0h.h[x12] }, p3/Z, [x26, x22, LSL #1]\n    ldr x26, [x10, #0x0]\n    KAI_ASM_INST(0xe0560b08)  // ld1h { za1h.h[x12] }, p2/Z, [x24, x22, LSL #1]\n    ldr x24, [x9, #0x0]\n    KAI_ASM_INST(0xe05606e2)  // ld1h { za0h.h[x12, #2] }, p1/Z, [x23, x22, LSL #1]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe05602aa)  // ld1h { za1h.h[x12, #2] }, p0/Z, [x21, x22, LSL #1]\n    add x12, x12, #0x4\n    ldr x21, [x9, #0x8]\n    add x9, x9, #0x10\n    cmp x12, x16, LSL #1\n    blt label_1\nKAI_ASM_LABEL(label_2)  // K loop: Charge: End\n    KAI_ASM_INST(0x25286163)  // psel p3.h, p8.h/Z, p11.h[w12]\n    KAI_ASM_INST(0x25286142)  // psel p2.h, p8.h/Z, p10.h[w12]\n    KAI_ASM_INST(0x25686161)  // psel p1.h, p8.h/Z, p11.h[w12, #2]\n    KAI_ASM_INST(0x25686140)  // psel p0.h, p8.h/Z, p10.h[w12, #2]\n    mov x10, x2\n    add x9, x2, x17, LSL #3\n    KAI_ASM_INST(0xe0560f40)  // ld1h { za0h.h[x12] }, p3/Z, [x26, x22, LSL #1]\n    ldr x26, [x10, #0x0]\n    inch x11\n    KAI_ASM_INST(0xe0560b08)  // ld1h { za1h.h[x12] }, p2/Z, [x24, x22, LSL #1]\n    ldr x24, [x9, #0x0]\n    KAI_ASM_INST(0xe05606e2)  // ld1h { za0h.h[x12, #2] }, p1/Z, [x23, x22, LSL #1]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe05602aa)  // ld1h { za1h.h[x12, #2] }, p0/Z, [x21, x22, LSL #1]\n    ldr x21, [x9, #0x8]\n    add x9, x9, #0x10\n    inch x22\n    cbz x13, label_8\n    mov x20, x13\nKAI_ASM_LABEL(label_3)  // K loop: Main loop\n    whilelt p8.h, x11, x1\n    mov x15, #0x0\n    mov x14, #0x0\n    cbz x16, label_5\nKAI_ASM_LABEL(label_4)  // K loop: Main loop: First: Loop\n    KAI_ASM_INST(0x253b6160)  // psel p0.h, p8.h/Z, p11.h[w15, #1]\n    KAI_ASM_INST(0x253b6142)  // psel p2.h, p8.h/Z, p10.h[w15, #1]\n    KAI_ASM_INST(0x257b6161)  // psel p1.h, p8.h/Z, p11.h[w15, #3]\n    KAI_ASM_INST(0x257b6143)  // psel p3.h, p8.h/Z, p10.h[w15, #3]\n    KAI_ASM_INST(0xe0566341)  // ld1h { za0h.h[x15, #1] }, p0/Z, [x26, x22, LSL #1]\n    KAI_ASM_INST(0x252a7120)  // psel p0.h, p12.h/Z, p9.h[w14]\n    ldr x26, [x10, #0x0]\n    KAI_ASM_INST(0xe0566b09)  // ld1h { za1h.h[x15, #1] }, p2/Z, [x24, x22, LSL #1]\n    KAI_ASM_INST(0x252a7122)  // psel p2.h, p12.h/Z, p9.h[w14]\n    ldr x24, [x9, #0x0]\n    KAI_ASM_INST(0xe05666e3)  // ld1h { za0h.h[x15, #3] }, p1/Z, [x23, x22, LSL #1]\n    KAI_ASM_INST(0x253a7121)  // psel p1.h, p12.h/Z, p9.h[w14, #1]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe0566eab)  // ld1h { za1h.h[x15, #3] }, p3/Z, [x21, x22, LSL #1]\n    ldr x21, [x9, #0x8]\n    KAI_ASM_INST(0xe0bfc060)  // st1w { za0v.s[x14] }, p0/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0x253a7120)  // psel p0.h, p12.h/Z, p9.h[w14, #1]\n    KAI_ASM_INST(0xe0b1c864)  // st1w { za1v.s[x14] }, p2/Z, [x3, x17, LSL #2]\n    add x9, x9, #0x10\n    add x15, x15, #0x4\n    KAI_ASM_INST(0xe0bcc461)  // st1w { za0v.s[x14, #1] }, p1/Z, [x3, x28, LSL #2]\n    KAI_ASM_INST(0xe0bbc065)  // st1w { za1v.s[x14, #1] }, p0/Z, [x3, x27, LSL #2]\n    add x14, x14, #0x2\n    addvl x3, x3, #4\n    cmp x14, x16\n    blt label_4\nKAI_ASM_LABEL(label_5)  // K loop: Main loop: First: Tail\n    KAI_ASM_INST(0x253b6160)  // psel p0.h, p8.h/Z, p11.h[w15, #1]\n    KAI_ASM_INST(0x253b6142)  // psel p2.h, p8.h/Z, p10.h[w15, #1]\n    KAI_ASM_INST(0x257b6161)  // psel p1.h, p8.h/Z, p11.h[w15, #3]\n    KAI_ASM_INST(0x257b6143)  // psel p3.h, p8.h/Z, p10.h[w15, #3]\n    mov x10, x2\n    add x9, x2, x17, LSL #3\n    KAI_ASM_INST(0xe0566341)  // ld1h { za0h.h[x15, #1] }, p0/Z, [x26, x22, LSL #1]\n    KAI_ASM_INST(0x252a7120)  // psel p0.h, p12.h/Z, p9.h[w14]\n    ldr x26, [x10, #0x0]\n    mov x13, #0x0\n    KAI_ASM_INST(0xe0566b09)  // ld1h { za1h.h[x15, #1] }, p2/Z, [x24, x22, LSL #1]\n    KAI_ASM_INST(0x252a7122)  // psel p2.h, p12.h/Z, p9.h[w14]\n    ldr x24, [x9, #0x0]\n    mov x12, #0x0\n    KAI_ASM_INST(0xe05666e3)  // ld1h { za0h.h[x15, #3] }, p1/Z, [x23, x22, LSL #1]\n    KAI_ASM_INST(0x253a7121)  // psel p1.h, p12.h/Z, p9.h[w14, #1]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe0566eab)  // ld1h { za1h.h[x15, #3] }, p3/Z, [x21, x22, LSL #1]\n    ldr x21, [x9, #0x8]\n    KAI_ASM_INST(0xe0bfc060)  // st1w { za0v.s[x14] }, p0/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0x253a7120)  // psel p0.h, p12.h/Z, p9.h[w14, #1]\n    KAI_ASM_INST(0xe0b1c864)  // st1w { za1v.s[x14] }, p2/Z, [x3, x17, LSL #2]\n    whilelt p9.h, x11, x1\n    inch x11\n    KAI_ASM_INST(0xe0bcc461)  // st1w { za0v.s[x14, #1] }, p1/Z, [x3, x28, LSL #2]\n    add x9, x9, #0x10\n    inch x22\n    KAI_ASM_INST(0xe0bbc065)  // st1w { za1v.s[x14, #1] }, p0/Z, [x3, x27, LSL #2]\n    addvl x3, x3, #4\n    whilelt p8.h, x11, x1\n    cbz x16, label_7\nKAI_ASM_LABEL(label_6)  // K loop: Main loop: Second: Loop\n    KAI_ASM_INST(0x25296160)  // psel p0.h, p8.h/Z, p11.h[w13]\n    KAI_ASM_INST(0x25296142)  // psel p2.h, p8.h/Z, p10.h[w13]\n    KAI_ASM_INST(0x25696161)  // psel p1.h, p8.h/Z, p11.h[w13, #2]\n    KAI_ASM_INST(0x25696143)  // psel p3.h, p8.h/Z, p10.h[w13, #2]\n    KAI_ASM_INST(0xe0562340)  // ld1h { za0h.h[x13] }, p0/Z, [x26, x22, LSL #1]\n    KAI_ASM_INST(0x25287120)  // psel p0.h, p12.h/Z, p9.h[w12]\n    ldr x26, [x10, #0x0]\n    KAI_ASM_INST(0xe0562b08)  // ld1h { za1h.h[x13] }, p2/Z, [x24, x22, LSL #1]\n    KAI_ASM_INST(0x25287122)  // psel p2.h, p12.h/Z, p9.h[w12]\n    ldr x24, [x9, #0x0]\n    KAI_ASM_INST(0xe05626e2)  // ld1h { za0h.h[x13, #2] }, p1/Z, [x23, x22, LSL #1]\n    KAI_ASM_INST(0x25387121)  // psel p1.h, p12.h/Z, p9.h[w12, #1]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe0562eaa)  // ld1h { za1h.h[x13, #2] }, p3/Z, [x21, x22, LSL #1]\n    ldr x21, [x9, #0x8]\n    KAI_ASM_INST(0xe0bf8068)  // st1w { za2v.s[x12] }, p0/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0x25387120)  // psel p0.h, p12.h/Z, p9.h[w12, #1]\n    KAI_ASM_INST(0xe0b1886c)  // st1w { za3v.s[x12] }, p2/Z, [x3, x17, LSL #2]\n    add x9, x9, #0x10\n    add x13, x13, #0x4\n    KAI_ASM_INST(0xe0bc8469)  // st1w { za2v.s[x12, #1] }, p1/Z, [x3, x28, LSL #2]\n    KAI_ASM_INST(0xe0bb806d)  // st1w { za3v.s[x12, #1] }, p0/Z, [x3, x27, LSL #2]\n    add x12, x12, #0x2\n    addvl x3, x3, #4\n    cmp x12, x16\n    blt label_6\nKAI_ASM_LABEL(label_7)  // K loop: Main loop: Second: Tail\n    KAI_ASM_INST(0x25296160)  // psel p0.h, p8.h/Z, p11.h[w13]\n    KAI_ASM_INST(0x25296142)  // psel p2.h, p8.h/Z, p10.h[w13]\n    KAI_ASM_INST(0x25696161)  // psel p1.h, p8.h/Z, p11.h[w13, #2]\n    KAI_ASM_INST(0x25696143)  // psel p3.h, p8.h/Z, p10.h[w13, #2]\n    mov x10, x2\n    add x9, x2, x17, LSL #3\n    KAI_ASM_INST(0xe0562340)  // ld1h { za0h.h[x13] }, p0/Z, [x26, x22, LSL #1]\n    KAI_ASM_INST(0x25287120)  // psel p0.h, p12.h/Z, p9.h[w12]\n    ldr x26, [x10, #0x0]\n    KAI_ASM_INST(0xe0562b08)  // ld1h { za1h.h[x13] }, p2/Z, [x24, x22, LSL #1]\n    KAI_ASM_INST(0x25287122)  // psel p2.h, p12.h/Z, p9.h[w12]\n    ldr x24, [x9, #0x0]\n    KAI_ASM_INST(0xe05626e2)  // ld1h { za0h.h[x13, #2] }, p1/Z, [x23, x22, LSL #1]\n    KAI_ASM_INST(0x25387121)  // psel p1.h, p12.h/Z, p9.h[w12, #1]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe0562eaa)  // ld1h { za1h.h[x13, #2] }, p3/Z, [x21, x22, LSL #1]\n    ldr x21, [x9, #0x8]\n    KAI_ASM_INST(0xe0bf8068)  // st1w { za2v.s[x12] }, p0/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0x25387120)  // psel p0.h, p12.h/Z, p9.h[w12, #1]\n    KAI_ASM_INST(0xe0b1886c)  // st1w { za3v.s[x12] }, p2/Z, [x3, x17, LSL #2]\n    whilelt p9.h, x11, x1\n    subs x20, x20, #0x1\n    KAI_ASM_INST(0xe0bc8469)  // st1w { za2v.s[x12, #1] }, p1/Z, [x3, x28, LSL #2]\n    add x9, x9, #0x10\n    inch x11\n    KAI_ASM_INST(0xe0bb806d)  // st1w { za3v.s[x12, #1] }, p0/Z, [x3, x27, LSL #2]\n    addvl x3, x3, #4\n    inch x22\n    bgt label_3\nKAI_ASM_LABEL(label_8)  // K loop: Tails\n    cbnz x25, label_11\n    mov x10, x2\n    whilelt p8.h, x11, x1\n    mov x13, #0x0\n    mov x12, #0x0\nKAI_ASM_LABEL(label_9)  // K loop: Tails: Even: First\n    KAI_ASM_INST(0x25307123)  // psel p3.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0x25307122)  // psel p2.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0x25396161)  // psel p1.h, p8.h/Z, p11.h[w13, #1]\n    KAI_ASM_INST(0x25396140)  // psel p0.h, p8.h/Z, p10.h[w13, #1]\n    KAI_ASM_INST(0xe0bf8c60)  // st1w { za0v.s[x12] }, p3/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0xe0b18864)  // st1w { za1v.s[x12] }, p2/Z, [x3, x17, LSL #2]\n    add x12, x12, #0x1\n    addvl x3, x3, #2\n    ldr x21, [x10, #0x0]\n    cmp x12, x17\n    ldr x20, [x10, x17, LSL #0x3]\n    add x10, x10, #0x8\n    KAI_ASM_INST(0xe05626a1)  // ld1h { za0h.h[x13, #1] }, p1/Z, [x21, x22, LSL #1]\n    KAI_ASM_INST(0xe0562289)  // ld1h { za1h.h[x13, #1] }, p0/Z, [x20, x22, LSL #1]\n    add x13, x13, #0x2\n    blt label_9\n    whilelt p9.h, x11, x1\n    whilelt p8.h, x11, x1\n    mov x20, #0x0\n    mov x12, #0x0\nKAI_ASM_LABEL(label_10)  // K loop: Tails: Even: Second\n    KAI_ASM_INST(0x25307121)  // psel p1.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0x25307120)  // psel p0.s, p12.s/Z, p9.s[w12]\n    add x20, x20, #0x2\n    KAI_ASM_INST(0xe0bf8468)  // st1w { za2v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0xe0b1806c)  // st1w { za3v.s[x12] }, p0/Z, [x3, x17, LSL #2]\n    add x12, x12, #0x1\n    addvl x3, x3, #2\n    cmp x12, x8\n    blt label_10\n    whilelt p8.h, x11, x1\n    b label_13\nKAI_ASM_LABEL(label_11)  // K loop: Tails: Odd\n    mov x12, #0x0\nKAI_ASM_LABEL(label_12)  // K loop: Tails: Odd: Loop\n    KAI_ASM_INST(0x25307121)  // psel p1.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0x25307120)  // psel p0.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0xe0bf8460)  // st1w { za0v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0xe0b18064)  // st1w { za1v.s[x12] }, p0/Z, [x3, x17, LSL #2]\n    add x12, x12, #0x1\n    addvl x3, x3, #2\n    cmp x12, x8\n    blt label_12\nKAI_ASM_LABEL(label_13)  // K loop: End\n    KAI_ASM_INST(0xd503467f)  // SMSTOP\n    ldp x22, x23, [sp, 16]\n    ldp x24, x25, [sp, 32]\n    ldp x26, x27, [sp, 48]\n    ldr x28, [sp, 64]\n    ldp d8, d9, [sp, 72]\n    ldp d10, d11, [sp, 88]\n    ldp d12, d13, [sp, 104]\n    ldp d14, d15, [sp, 120]\n    ldp x20, x21, [sp], 144\n    ret\n    KAI_ASM_FUNCTION_END(kai_kernel_lhs_imatmul_pack_x16p2vlx2_x16p_sme)\n\n    KAI_ASM_END\n"
+    },
+    {
+      "path": "kai_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme.h",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include <stddef.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif  // __cplusplus\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(void);\n\n/// Gets the offset in bytes to the data element in the RHS matrix buffer.\n///\n/// @param[in] n_idx Column index. Must be divisible by `n_step`\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_offset_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(size_t n_idx);\n\n/// Gets the offset in bytes to the data element in the bias buffer.\n///\n/// @param[in] n_idx Column index.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_bias_offset_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(size_t n_idx);\n\n/// Gets row stride in bytes of the packed RHS matrix.\n///\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n///\n/// @return Row stride in bytes.\nsize_t kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n    size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the offset in bytes to the data element in the packed RHS buffer.\n///\n/// @param[in] n_idx Column index. Must be divisible by `n_step`\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n    size_t n_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the size in bytes of the packed RHS buffer.\n///\n/// @param[in] n Number of columns.\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n///\n/// @return The size in bytes of the packed RHS buffer.\nsize_t kai_get_rhs_packed_size_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n    size_t n, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Runs the RHS packing function for matrix multiplication.\n///\n/// The pointer of each buffer (RHS, bias and packed RHS) needs to be added with offset\n/// calculated using the following functions:\n///\n///   * RHS: @ref kai_get_rhs_offset_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme.\n///   * Bias: @ref kai_get_bias_offset_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme.\n///   * Output: @ref kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme.\n///\n/// @param[in] n Number of columns of the output matrix.\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n/// @param[in] rhs_stride_row Row stride in bytes of the RHS matrix.\n/// @param[in] rhs RHS matrix data buffer.\n/// @param[in] bias Bias matrix data buffer.\n/// @param[out] rhs_packed Packed RHS matrix.\nvoid kai_run_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n    size_t n, size_t k_chunk_count, size_t k_chunk_length, size_t rhs_stride_row, const void* rhs, const void* bias,\n    void* rhs_packed);\n\n#ifdef __cplusplus\n}  // extern \"C\"\n#endif  // __cplusplus\n"
+    },
+    {
+      "path": "kai_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme.c",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else  // Architectural features check.\n\n#include \"kai_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme.h\"\n\n#include <stddef.h>\n#include <stdint.h>\n#include <string.h>\n\n#include \"kai/kai_common.h\"\n\nenum {\n    NR = 2,\n    KR = 2,\n    MAX_N_STEP = NR * ((KAI_SME_VEC_LENGTH_MAX_BYTES / sizeof(uint16_t)) / KR),\n};\n\ntypedef struct {\n    const void* bias_ptr;\n    size_t width;\n    size_t height;\n    size_t k_chunk_count;\n    size_t in_stride;\n    size_t out_stride;\n    const void* in;\n    void* out;\n    const void* pad_row;\n} KernelArgs;\n\nstatic const size_t kai_num_bytes_input = sizeof(uint16_t);\nstatic const size_t kai_num_bytes_output = sizeof(uint16_t);\nstatic const size_t kai_num_bytes_bias = sizeof(uint16_t);\n\nvoid kai_kernel_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(const KernelArgs* args_ptr);\n\nsize_t kai_get_n_step_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(void) {\n    return NR * kai_get_sme_vector_length_u16() / KR;\n}\n\nsize_t kai_get_rhs_offset_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(size_t n_idx) {\n    KAI_ASSUME(n_idx % kai_get_n_step_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme() == 0);\n\n    return n_idx * kai_num_bytes_input;\n}\n\nsize_t kai_get_bias_offset_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(size_t n_idx) {\n    return n_idx * kai_num_bytes_bias;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n    size_t k_chunk_count, size_t k_chunk_length) {\n    return kai_get_n_step_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme() *\n        (kai_num_bytes_bias + k_chunk_count * kai_roundup(k_chunk_length, KR) * kai_num_bytes_output);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n    size_t n_idx, size_t k_chunk_count, size_t k_chunk_length) {\n    KAI_ASSUME(n_idx % kai_get_n_step_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme() == 0);\n\n    const size_t block_idx = n_idx / kai_get_n_step_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme();\n    return block_idx *\n        kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(k_chunk_count, k_chunk_length);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n    size_t n, size_t k_chunk_count, size_t k_chunk_length) {\n    const size_t n_nr_blocks = kai_roundup(n, kai_get_n_step_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme());\n    return kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n        n_nr_blocks, k_chunk_count, k_chunk_length);\n}\n\nvoid kai_run_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n    size_t n, size_t k_chunk_count, size_t k_chunk_length, size_t rhs_stride_row, const void* rhs, const void* bias,\n    void* rhs_packed) {\n    KAI_ASSUME(rhs != NULL);\n    KAI_ASSUME(bias != NULL);\n    KAI_ASSUME(rhs_packed != NULL);\n\n    KAI_ASSERT(kai_get_n_step_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme() <= MAX_N_STEP);\n    static const uint16_t pad_row[MAX_N_STEP] = {0};\n\n    KernelArgs args;\n    args.bias_ptr = bias;\n    args.height = k_chunk_length;\n    args.width = n;\n    args.in = rhs;\n    args.out = rhs_packed;\n    args.k_chunk_count = k_chunk_count;\n    args.in_stride = rhs_stride_row;\n    args.out_stride =\n        kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(k_chunk_count, k_chunk_length);\n    args.pad_row = pad_row;\n\n    kai_commit_za();\n\n    kai_kernel_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(&args);\n}\n\n#endif  // Architectural features check.\n"
+    },
+    {
+      "path": "kai_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme_asm.S",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n    #define KAI_ASM_GLOBAL(name) GLOBAL name\n    #define KAI_ASM_FUNCTION_TYPE(name)\n    #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n    #define KAI_ASM_FUNCTION_END(name) ENDP\n\n    #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n    #define KAI_ASM_ALIGN\n    #define KAI_ASM_LABEL(name) name\n    #define KAI_ASM_INST(hex) DCD hex\n    #define KAI_ASM_END END\n#else\n    #if defined(__APPLE__)\n        #define KAI_ASM_GLOBAL(name) .globl _##name\n        #define KAI_ASM_FUNCTION_TYPE(name)\n        #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n        #define KAI_ASM_FUNCTION_END(name)\n    #else\n        #define KAI_ASM_GLOBAL(name) .global name\n        #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n        #define KAI_ASM_FUNCTION_LABEL(name) name:\n        #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n    #endif\n\n    #define KAI_ASM_CODE(name) .text\n    #define KAI_ASM_ALIGN .p2align 4,,11\n    #define KAI_ASM_LABEL(name) name:\n    #define KAI_ASM_INST(hex) .inst hex\n    #define KAI_ASM_END\n#endif\n\n    KAI_ASM_CODE(rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme)\n    KAI_ASM_ALIGN\n\n    KAI_ASM_GLOBAL(kai_kernel_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme)\n    stp x20, x21, [sp, -144]!\n    stp x22, x23, [sp, 16]\n    stp x24, x25, [sp, 32]\n    stp x26, x27, [sp, 48]\n    str x28, [sp, 64]\n    stp d8, d9, [sp, 72]\n    stp d10, d11, [sp, 88]\n    stp d12, d13, [sp, 104]\n    stp d14, d15, [sp, 120]\n    KAI_ASM_INST(0xd503477f)  // SMSTART ZA\n    ldr x8, [x0, #0x8]\n    ptrue p1.b\n    ldr x17, [x0, #0x38]\n    ldr x23, [x0, #0x0]\n    ldr x16, [x0, #0x10]\n    mov x22, x8\n    ldr x21, [x0, #0x18]\n    mov x20, x17\n    ldr x15, [x0, #0x20]\n    ldr x14, [x0, #0x28]\n    ldr x13, [x0, #0x30]\n    ldr x12, [x0, #0x40]\nKAI_ASM_LABEL(label_1)  // Bias: Full loop\n    whilelt p0.h, XZR, x22\n    dech x22\n    cmp x22, #0x0\n    ld1h { z16.h }, p0/Z, [x23]\n    incb x23\n    st1h { z16.h }, p1, [x20]\n    add x20, x20, x14\n    bgt label_1\n    incb x17\n    mov x11, x21\nKAI_ASM_LABEL(label_2)  // Chunk Loop\n    mov x10, x16\n    cmp x10, #0x8\n    blt label_6\nKAI_ASM_LABEL(label_3)  // Main row loop: Head\n    mov x9, x13\n    mov x28, x17\n    add x27, x9, x15\n    sub x10, x10, #0x8\n    add x26, x27, x15\n    mov x25, x8\n    add x24, x26, x15\n    add x23, x24, x15\n    add x22, x23, x15\n    add x21, x22, x15\n    add x20, x21, x15\n    add x13, x20, x15\nKAI_ASM_LABEL(label_4)  // Main row loop: Column loop\n    whilelt p0.h, XZR, x25\n    decw x25, ALL, MUL #2\n    ld1h { z20.h }, p0/Z, [x9]\n    cmp x25, #0x0\n    addvl x9, x9, #1\n    ld1h { z17.h }, p0/Z, [x27]\n    addvl x27, x27, #1\n    ld1h { z19.h }, p0/Z, [x26]\n    addvl x26, x26, #1\n    ld1h { z16.h }, p0/Z, [x24]\n    addvl x24, x24, #1\n    ld1h { z18.h }, p0/Z, [x23]\n    addvl x23, x23, #1\n    zip1 z24.h, z20.h, z17.h\n    zip2 z23.h, z20.h, z17.h\n    ld1h { z17.h }, p0/Z, [x22]\n    addvl x22, x22, #1\n    ld1h { z22.h }, p0/Z, [x21]\n    addvl x21, x21, #1\n    zip1 z21.h, z19.h, z16.h\n    zip2 z20.h, z19.h, z16.h\n    ld1h { z16.h }, p0/Z, [x20]\n    addvl x20, x20, #1\n    zip1 z19.h, z18.h, z17.h\n    zip2 z18.h, z18.h, z17.h\n    st1h { z24.h }, p1, [x28]\n    st1h { z23.h }, p1, [x28, #1, MUL VL]\n    zip1 z17.h, z22.h, z16.h\n    zip2 z16.h, z22.h, z16.h\n    st1h { z21.h }, p1, [x28, #2, MUL VL]\n    st1h { z20.h }, p1, [x28, #3, MUL VL]\n    st1h { z19.h }, p1, [x28, #4, MUL VL]\n    st1h { z18.h }, p1, [x28, #5, MUL VL]\n    st1h { z17.h }, p1, [x28, #6, MUL VL]\n    st1h { z16.h }, p1, [x28, #7, MUL VL]\n    add x28, x28, x14\n    bgt label_4\n    cmp x10, #0x8\n    addvl x17, x17, #8\n    bge label_3\n    cbz x10, label_10\nKAI_ASM_LABEL(label_6)  // Main loop skip\nKAI_ASM_LABEL(label_7)  // Tail row loop: Head\n    mov x9, x13\n    cntw x22, ALL, MUL #4\n    add x27, x9, x15\n    cmp x10, #0x1\n    add x13, x27, x15\n    mov x28, x17\n    csel x13, x13, x27, GT\n    csel x27, x27, x12, GT\n    csel x21, x22, XZR, GT\n    sub x10, x10, #0x2\n    mov x20, x8\nKAI_ASM_LABEL(label_8)  // Tail row loop: Column loop\n    whilelt p0.h, XZR, x20\n    decw x20, ALL, MUL #2\n    ld1h { z18.h }, p0/Z, [x9]\n    cmp x20, #0x0\n    add x9, x9, x22\n    ld1h { z16.h }, p0/Z, [x27]\n    add x27, x27, x21\n    zip1 z17.h, z18.h, z16.h\n    zip2 z16.h, z18.h, z16.h\n    st1h { z17.h }, p1, [x28]\n    st1h { z16.h }, p1, [x28, #1, MUL VL]\n    add x28, x28, x14\n    bgt label_8\n    cmp x10, #0x1\n    addvl x17, x17, #2\n    bge label_7\nKAI_ASM_LABEL(label_10)  // Done\n    sub x11, x11, #0x1\n    cbnz x11, label_2\n    KAI_ASM_INST(0xd503467f)  // SMSTOP\n    ldp x22, x23, [sp, 16]\n    ldp x24, x25, [sp, 32]\n    ldp x26, x27, [sp, 48]\n    ldr x28, [sp, 64]\n    ldp d8, d9, [sp, 72]\n    ldp d10, d11, [sp, 88]\n    ldp d12, d13, [sp, 104]\n    ldp d14, d15, [sp, 120]\n    ldp x20, x21, [sp], 144\n    ret\n    KAI_ASM_FUNCTION_END(kai_kernel_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme)\n\n    KAI_ASM_END\n"
+    },
     {
       "path": "kai_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot.h",
       "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include <stddef.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif  // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_rhs_pack_kxn_x16p2vlx2b_x16_x16_sme\n\n/// --------------------------------------------------\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(void);\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(void);\n\n/// Gets nr value.\n///\n/// This is the packing parameter which must be used to pack the RHS matrix.\n///\n/// @return The nr value.\nsize_t kai_get_nr_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(void);\n\n/// Gets kr value.\n///\n/// This is the packing parameter which must be used to pack the RHS matrix.\n///\n/// @return The kr value.\nsize_t kai_get_kr_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(void);\n\n/// Gets sr value.\n///\n/// This is the packing parameter which must be used to pack the RHS matrix.\n///\n/// @return The sr value.\nsize_t kai_get_sr_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(void);\n\n/// Gets the offset in bytes to the data element in the LHS matrix buffer.\n///\n/// @param[in] m_idx Row index. This must be 0.\n/// @param[in] k     Columns of unpacked LHS.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes to the data element in the packed RHS matrix buffer.\n///\n/// @param[in] n_idx Column index in the unpacked RHS matrix. Must be a multiple of n_step\n/// @param[in] k Number of rows in the unpacked RHS matrix.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(size_t n_idx, size_t k);\n\n/// Gets the offset in bytes to the data element in the destination matrix buffer.\n///\n/// @param[in] m_idx Row index. Must be 0\n/// @param[in] n_idx Column index. Must be multiple of n_step\n/// @param[in] dst_stride Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_dst_offset_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(\n    size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes of the destination matrix buffer.\n///\n/// @param[in] m Number of rows.\n/// @param[in] n Number of columns.\n///\n/// @return The size in bytes of the destination matrix buffer.\nsize_t kai_get_dst_size_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(size_t m, size_t n);\n\n/// Runs the matrix multiplication microkernel followed by a clamp operation.\n///\n/// The pointer of each buffers (LHS, packed RHS and output) needs to be added with offset\n/// calculated using the following functions:\n///\n///   * LHS: @ref kai_get_lhs_offset_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot.\n///   * Packed RHS: @ref kai_get_rhs_packed_offset_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot.\n///   * Output: @ref kai_get_dst_offset_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot.\n///\n/// @param[in]  m Number of output rows to be computed. This must be 1.\n/// @param[in]  n Number of output columns to be computed.\n/// @param[in]  k Common dimension of the LHS and RHS operand.\n/// @param[in]  lhs LHS matrix buffer.\n/// @param[in]  rhs_packed Packed RHS matrix buffer.\n/// @param[out] dst Output matrix buffer.\n/// @param[in]  dst_stride_row Row stride in bytes of the output matrix. Unused\n/// @param[in]  dst_stride_col Column stride in bytes of the output matrix. Unused\n/// @param[in]  clamp_min Minimum value to clamp the final result.\n/// @param[in]  clamp_max Maximum value to clamp the final result.\n///\n/// @note Clamp minimum and maximum values are cast internally to the destination type before clamping the computed\n/// values.\n///\nvoid kai_run_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(\n    size_t m, size_t n, size_t k, const void* lhs, size_t lhs_stride, const void* rhs_packed, void* dst,\n    size_t dst_stride_row, size_t dst_stride_col, float clamp_min, float clamp_max);\n\n#ifdef __cplusplus\n}  // extern \"C\"\n#endif  // __cplusplus\n"
@@ -58,7 +94,7 @@
     },
     {
       "path": "binding.cpp",
-      "content": "// Binding for Arm KleidiAI's\n// kai_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot (pure SME2 GEMM,\n// f16 throughout, UNPACKED LHS) against gemm_f16_n512_k512's raw ABI:\n//   armbench_entry_gemm(A*, output*, B*, bias*, M), C = A @ B + bias.\n//\n// Same shape as gemm_fp32_sme2_n512_k512's baseline (LHS unpacked, m==1\n// per-call restriction -> per-row loop), just f16 dtype throughout instead\n// of f32. Only difference: the kernel's dst is f16, but this repo's\n// RawDataset always allocates a float32 output buffer, so each row is\n// computed into a small f16 scratch buffer then converted to f32 in place.\n//\n// B arrives [K,N] row-major, matching kai_rhs_pack_kxn_...'s native \"kxn\"\n// input layout directly -- no transpose needed.\n#include <cstdint>\n#include <cstdlib>\n#include <cstring>\n#include <limits>\n#include <vector>\n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot.h\"\n#include \"kai_rhs_pack_kxn_x16p2vlx2b_x16_x16_sme.h\"\n\nnamespace {\nconstexpr int N = 512;\nconstexpr int K = 512;\n\n// Minimal IEEE754 half -> float32 (matches this repo's raw uint16_t f16 bit-pattern ABI).\nfloat f16_to_f32(uint16_t h)\n{\n    uint32_t sign = (uint32_t)(h & 0x8000) << 16;\n    uint32_t exp = (h >> 10) & 0x1F;\n    uint32_t mant = h & 0x3FF;\n    uint32_t bits;\n    if (exp == 0) {\n        bits = sign;\n    } else {\n        bits = sign | ((exp - 15 + 127) << 23) | (mant << 13);\n    }\n    float f;\n    std::memcpy(&f, &bits, sizeof(f));\n    return f;\n}\n\n// True if `data` (size bytes) differs from the cached snapshot, and updates\n// the snapshot to match when it does. Content-based, not pointer-based --\n// see conv2d_depthwise_fp32_nhwc_kh3_kw3_s1_p1's binding.cpp for why\n// (github.com/ArtificialRay/CPU-Kernel-Baseline/issues/80).\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n    const bool stale =\n        snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n    if (stale) {\n        if (snapshot_size != size) {\n            std::free(snapshot);\n            snapshot = static_cast<uint8_t*>(std::malloc(size));\n            snapshot_size = size;\n        }\n        std::memcpy(snapshot, data, size);\n    }\n    return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(\n    const uint16_t* A, float* output, const uint16_t* B, const uint16_t* bias, int M)\n{\n    const size_t nr = kai_get_nr_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot();\n    const size_t kr = kai_get_kr_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot();\n    const size_t sr = kai_get_sr_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot();\n\n    // --- RHS: pack B [K, N] f16 (+ bias), cached across calls whose B AND\n    // bias content match the last pack.\n    static uint8_t* B_snapshot = nullptr;\n    static size_t B_snapshot_size = 0;\n    static uint8_t* bias_snapshot = nullptr;\n    static size_t bias_snapshot_size = 0;\n    static void* rhs_packed = nullptr;\n    const size_t B_bytes = sizeof(uint16_t) * (size_t)N * (size_t)K;\n    const size_t bias_bytes = sizeof(uint16_t) * (size_t)N;\n    const bool B_stale = refresh_cache(B_snapshot, B_snapshot_size, B, B_bytes);\n    const bool bias_stale = refresh_cache(bias_snapshot, bias_snapshot_size, bias, bias_bytes);\n    if (B_stale || bias_stale) {\n        std::free(rhs_packed);\n        const size_t rhs_packed_size =\n            kai_get_rhs_packed_size_rhs_pack_kxn_x16p2vlx2b_x16_x16_sme((size_t)N, (size_t)K);\n        rhs_packed = std::malloc(rhs_packed_size);\n        if (rhs_packed == nullptr) return -1;\n\n        kai_run_rhs_pack_kxn_x16p2vlx2b_x16_x16_sme(\n            /*num_groups=*/1, (size_t)N, (size_t)K, nr, kr, sr,\n            /*rhs_stride_row=*/(size_t)N * sizeof(uint16_t), B, bias, /*scale=*/nullptr,\n            rhs_packed, /*extra_bytes=*/0, /*params=*/nullptr);\n    }\n\n    // --- matmul + clamp: LHS is unpacked, loop one row at a time (m == 1) ---\n    std::vector<uint16_t> row_out(N);\n    for (int m_idx = 0; m_idx < M; ++m_idx) {\n        const uint16_t* lhs_row = A + (size_t)m_idx * (size_t)K;\n\n        kai_run_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(\n            /*m=*/1, (size_t)N, (size_t)K,\n            lhs_row, /*lhs_stride=*/(size_t)K * sizeof(uint16_t), rhs_packed,\n            row_out.data(),\n            /*dst_stride_row=*/(size_t)N * sizeof(uint16_t), /*dst_stride_col=*/sizeof(uint16_t),\n            -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());\n\n        float* out_row = output + (size_t)m_idx * (size_t)N;\n        for (int n = 0; n < N; ++n) out_row[n] = f16_to_f32(row_out[n]);\n    }\n\n    return 0;\n}\n"
+      "content": "// Binding for Arm KleidiAI's f16 SME2 GEMM against gemm_f16_n512_k512's raw\n// ABI: armbench_entry_gemm(A*, output*, B*, bias*, M), C = A @ B + bias.\n//\n// DISPATCHES between two real kernels by M:\n//   M <  DISPATCH_THRESHOLD (8): kai_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot\n//     -- a GEMV kernel (m_step=1, UNPACKED LHS), looped once per row (M is\n//     always small here so the loop is cheap).\n//   M >= DISPATCH_THRESHOLD: kai_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa\n//     -- a genuine multi-row SME2 mopa kernel, called ONCE for the whole M\n//     via a trivial k_chunk_count=1 indirection table (a plain GEMM is a\n//     convolution with one tap of length K).\n//\n// Why 8, not 1: on Apple M4 this mopa kernel's own m_step is\n// mr(2) * (streaming_vector_length_u16 / kr(2)) = 2 * (512-bit SVL / 2 / 2)\n// = 32 -- any M in [1, 32] costs the SAME (padded to one 32-row block), so\n// the new kernel's latency is roughly FLAT for M < 32 while the old GEMV\n// kernel's latency scales with M. Measured on Apple M4 (this repo's\n// enlarged M=1/4/8 decode points): the GEMV kernel is faster at M=1 (0.76x)\n// AND M=4 (0.77x of the mopa kernel's time), and the mopa kernel only wins\n// starting at M=8 (0.75x, i.e. already faster there) -- see\n// project memory for the full table. 8 is picked as the exact point where\n// the crossover was observed to have already happened, not a magic number.\n//\n// RHS packing is a DIFFERENT function/format for each kernel\n// (kai_rhs_pack_kxn_x16p2vlx2b_x16_x16_sme for the GEMV path vs.\n// kai_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme for the mopa path, despite\n// the near-identical name) -- so each path keeps its OWN independent\n// weight-content cache; whichever path is NOT taken for a given call never\n// touches its cache, so no wasted work. Within one timed workload run, M is\n// constant across all repeat/warmup calls, so only one of the two caches\n// ever actually gets built for that run.\n#include <arm_neon.h>\n#include <cstdint>\n#include <cstdlib>\n#include <cstring>\n#include <limits>\n#include <vector>\n\n#include \"kai/kai_common.h\"\n#include \"kai_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa.h\"\n#include \"kai_lhs_imatmul_pack_x16p2vlx2_x16p_sme.h\"\n#include \"kai_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot.h\"\n#include \"kai_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme.h\"\n#include \"kai_rhs_pack_kxn_x16p2vlx2b_x16_x16_sme.h\"\n\nnamespace {\nconstexpr int N = 512;\nconstexpr int K = 512;\nconstexpr int DISPATCH_THRESHOLD = 8;  // M < this -> GEMV kernel, else -> GEMM kernel. See file header.\n\n// Minimal IEEE754 half -> float32 (matches this repo's raw uint16_t f16 bit-pattern ABI).\nfloat f16_to_f32(uint16_t h)\n{\n    uint32_t sign = (uint32_t)(h & 0x8000) << 16;\n    uint32_t exp = (h >> 10) & 0x1F;\n    uint32_t mant = h & 0x3FF;\n    uint32_t bits;\n    if (exp == 0) {\n        bits = sign;\n    } else {\n        bits = sign | ((exp - 15 + 127) << 23) | (mant << 13);\n    }\n    float f;\n    std::memcpy(&f, &bits, sizeof(f));\n    return f;\n}\n\n// True if `data` (size bytes) differs from the cached snapshot, and updates\n// the snapshot to match when it does. Content-based, not pointer-based --\n// see conv2d_depthwise_fp32_nhwc_kh3_kw3_s1_p1's binding.cpp for why\n// (github.com/ArtificialRay/CPU-Kernel-Baseline/issues/80).\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n    const bool stale =\n        snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n    if (stale) {\n        if (snapshot_size != size) {\n            std::free(snapshot);\n            snapshot = static_cast<uint8_t*>(std::malloc(size));\n            snapshot_size = size;\n        }\n        std::memcpy(snapshot, data, size);\n    }\n    return stale;\n}\n\n// --- GEMV path (M < DISPATCH_THRESHOLD): kai_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot,\n// unpacked LHS, one row per call. Own weight cache (own RHS pack format). ---\nint run_gemv(const uint16_t* A, float* output, const uint16_t* B, const uint16_t* bias, int M)\n{\n    const size_t nr = kai_get_nr_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot();\n    const size_t kr = kai_get_kr_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot();\n    const size_t sr = kai_get_sr_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot();\n\n    static uint8_t* B_snapshot = nullptr;\n    static size_t B_snapshot_size = 0;\n    static uint8_t* bias_snapshot = nullptr;\n    static size_t bias_snapshot_size = 0;\n    static void* rhs_packed = nullptr;\n    const size_t B_bytes = sizeof(uint16_t) * (size_t)N * (size_t)K;\n    const size_t bias_bytes = sizeof(uint16_t) * (size_t)N;\n    const bool B_stale = refresh_cache(B_snapshot, B_snapshot_size, B, B_bytes);\n    const bool bias_stale = refresh_cache(bias_snapshot, bias_snapshot_size, bias, bias_bytes);\n    if (B_stale || bias_stale) {\n        std::free(rhs_packed);\n        const size_t rhs_packed_size =\n            kai_get_rhs_packed_size_rhs_pack_kxn_x16p2vlx2b_x16_x16_sme((size_t)N, (size_t)K);\n        rhs_packed = std::malloc(rhs_packed_size);\n        if (rhs_packed == nullptr) return -1;\n\n        kai_run_rhs_pack_kxn_x16p2vlx2b_x16_x16_sme(\n            /*num_groups=*/1, (size_t)N, (size_t)K, nr, kr, sr,\n            /*rhs_stride_row=*/(size_t)N * sizeof(uint16_t), B, bias, /*scale=*/nullptr,\n            rhs_packed, /*extra_bytes=*/0, /*params=*/nullptr);\n    }\n\n    static uint16_t* row_out = nullptr;\n    if (row_out == nullptr) {\n        row_out = static_cast<uint16_t*>(std::malloc((size_t)N * sizeof(uint16_t)));\n        if (row_out == nullptr) return -1;\n    }\n    for (int m_idx = 0; m_idx < M; ++m_idx) {\n        const uint16_t* lhs_row = A + (size_t)m_idx * (size_t)K;\n\n        kai_run_matmul_clamp_f16_f16_f16p2vlx2b_1x16vl_sme2_dot(\n            /*m=*/1, (size_t)N, (size_t)K,\n            lhs_row, /*lhs_stride=*/(size_t)K * sizeof(uint16_t), rhs_packed,\n            row_out,\n            /*dst_stride_row=*/(size_t)N * sizeof(uint16_t), /*dst_stride_col=*/sizeof(uint16_t),\n            -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());\n\n        float* out_row = output + (size_t)m_idx * (size_t)N;\n        for (int n = 0; n < N; ++n) out_row[n] = f16_to_f32(row_out[n]);\n    }\n    return 0;\n}\n\n// --- GEMM path (M >= DISPATCH_THRESHOLD): kai_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa,\n// called once for the whole M via a trivial k_chunk_count=1 indirection.\n// Own weight cache (own RHS pack format). ---\nint run_gemm(const uint16_t* A, float* output, const uint16_t* B, const uint16_t* bias, int M)\n{\n    const size_t k_chunk_count = 1;\n    const size_t k_chunk_length = (size_t)K;\n    const size_t m_step = kai_get_m_step_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa();\n    const size_t num_blocks = ((size_t)M + m_step - 1) / m_step;\n\n    static uint16_t* pad_chunk = nullptr;\n    if (pad_chunk == nullptr) {\n        pad_chunk = static_cast<uint16_t*>(std::calloc((size_t)K, sizeof(uint16_t)));\n        if (pad_chunk == nullptr) return -1;\n    }\n\n    static const uint16_t* cached_A = nullptr;\n    static int cached_M = -1;\n    static const void** indirection = nullptr;\n    static void* lhs_packed = nullptr;\n    static size_t lhs_cap = 0;\n    if (A != cached_A || M != cached_M) {\n        std::free(indirection);\n        const size_t total_slots = num_blocks * m_step * k_chunk_count;\n        indirection = static_cast<const void**>(std::malloc(sizeof(void*) * total_slots));\n        if (indirection == nullptr) { cached_A = nullptr; return -1; }\n\n        for (size_t block = 0; block < num_blocks; ++block) {\n            const size_t m_block_start = block * m_step;\n            for (size_t row = 0; row < m_step; ++row) {\n                const size_t dst_idx = block * m_step + row;\n                const size_t m_idx = m_block_start + row;\n                indirection[dst_idx] = (m_idx < (size_t)M) ? (const void*)(A + m_idx * (size_t)K) : pad_chunk;\n            }\n        }\n        cached_A = A;\n        cached_M = M;\n    }\n    {\n        const size_t lhs_packed_size =\n            kai_get_lhs_packed_size_lhs_imatmul_pack_x16p2vlx2_x16p_sme((size_t)M, k_chunk_count, k_chunk_length);\n        if (lhs_packed_size > lhs_cap) {\n            std::free(lhs_packed);\n            lhs_packed = std::malloc(lhs_packed_size);\n            lhs_cap = lhs_packed_size;\n            if (lhs_packed == nullptr) return -1;\n        }\n        kai_run_lhs_imatmul_pack_x16p2vlx2_x16p_sme(\n            (size_t)M, k_chunk_count, k_chunk_length, indirection, /*lhs_ptr_offset=*/0, pad_chunk, lhs_packed);\n    }\n\n    static uint8_t* B_snapshot = nullptr;\n    static size_t B_snapshot_size = 0;\n    static uint8_t* bias_snapshot = nullptr;\n    static size_t bias_snapshot_size = 0;\n    static void* rhs_packed = nullptr;\n    const size_t B_bytes = sizeof(uint16_t) * (size_t)N * (size_t)K;\n    const size_t bias_bytes = sizeof(uint16_t) * (size_t)N;\n    const bool B_stale = refresh_cache(B_snapshot, B_snapshot_size, B, B_bytes);\n    const bool bias_stale = refresh_cache(bias_snapshot, bias_snapshot_size, bias, bias_bytes);\n    if (B_stale || bias_stale) {\n        std::free(rhs_packed);\n        const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n            (size_t)N, k_chunk_count, k_chunk_length);\n        rhs_packed = std::malloc(rhs_packed_size);\n        if (rhs_packed == nullptr) return -1;\n\n        kai_run_rhs_imatmul_pack_kxn_x16p2vlx2b_x16_x16_sme(\n            (size_t)N, k_chunk_count, k_chunk_length,\n            /*rhs_stride_row=*/(size_t)N * sizeof(uint16_t), B, bias, rhs_packed);\n    }\n\n    const size_t out_elems = (size_t)M * (size_t)N;\n    static uint16_t* f16_out_buf = nullptr;\n    static size_t f16_out_cap = 0;\n    if (out_elems > f16_out_cap) {\n        std::free(f16_out_buf);\n        f16_out_buf = static_cast<uint16_t*>(std::malloc(out_elems * sizeof(uint16_t)));\n        f16_out_cap = out_elems;\n        if (f16_out_buf == nullptr) return -1;\n    }\n\n    kai_run_imatmul_clamp_f16_f16p2vlx2_f16p2vlx2_2vlx2vl_sme2_mopa(\n        (size_t)M, (size_t)N, k_chunk_count, k_chunk_length, lhs_packed, rhs_packed,\n        f16_out_buf, /*dst_stride_row=*/(size_t)N * sizeof(uint16_t),\n        -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());\n\n    {\n        size_t i = 0;\n        for (; i + 8 <= out_elems; i += 8) {\n            const uint16x8_t h = vld1q_u16(f16_out_buf + i);\n            vst1q_f32(output + i, vcvt_f32_f16(vreinterpret_f16_u16(vget_low_u16(h))));\n            vst1q_f32(output + i + 4, vcvt_f32_f16(vreinterpret_f16_u16(vget_high_u16(h))));\n        }\n        for (; i < out_elems; ++i) output[i] = f16_to_f32(f16_out_buf[i]);\n    }\n    return 0;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(\n    const uint16_t* A, float* output, const uint16_t* B, const uint16_t* bias, int M)\n{\n    return (M < DISPATCH_THRESHOLD) ? run_gemv(A, output, B, bias, M) : run_gemm(A, output, B, bias, M);\n}\n"
     }
   ]
 }

solutions/kleidiai/baseline-kleidiai-arm/gemm/gemm_fp32_sme2_n512_k512.json

@@ -3,7 +3,7 @@
   "definition": "gemm_fp32_sme2_n512_k512",
   "dataset": "kleidiai",
   "author": "baseline-kleidiai-arm",
-  "description": "Real ARM KleidiAI SME2 plain fp32 GEMM kernel (kai_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla, unpacked LHS) -- hand-vendored .c/.h/.S sources + custom binding.cpp against gemm_fp32_sme2_n512_k512's raw ABI. Requires SME2 (mac-m4.metal only).",
+  "description": "Arm KleidiAI fp32 SME2 GEMM: DISPATCHES between two real kernels by M. M<8 uses kai_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla (GEMV, m_step=1, unpacked LHS, looped once per row -- this repo's original baseline for this definition). M>=8 uses kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa (genuine multi-row SME2 GEMM via the mopa engine, called ONCE for the whole M through a trivial k_chunk_count=1 indirection table -- this session's earlier GEMM-only replacement). Same rationale as gemm_f16_n512_k512's dispatch (identical m_step=32 math on Apple M4 for this kernel family). Each path keeps its OWN independent weight-content cache. Verified on Apple M4: all 13 workloads PASSED against the real reference; M=1 is 36% faster and M=4 is 37% faster than the GEMM-only binding this replaces, M>=8 is within measurement noise of it. Both kernels vendored verbatim from github.com/ARM-software/kleidiai.",
   "spec": {
     "language": "cpp",
     "target_hardware": [
@@ -32,6 +32,42 @@
       "path": "kai/kai_common_sme_asm.S",
       "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n    #define KAI_ASM_GLOBAL(name) GLOBAL name\n    #define KAI_ASM_FUNCTION_TYPE(name)\n    #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n    #define KAI_ASM_FUNCTION_END(name) ENDP\n    #define KAI_ASM_FUNCTION_USE(name) name\n\n    #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n    #define KAI_ASM_ALIGN\n    #define KAI_ASM_LABEL(name) name\n    #define KAI_ASM_INST(hex) DCD hex\n    #define KAI_ASM_END END\n#else\n    #if defined(__APPLE__)\n        #define KAI_ASM_GLOBAL(name) .globl _##name\n        #define KAI_ASM_FUNCTION_TYPE(name)\n        #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n        #define KAI_ASM_FUNCTION_END(name)\n        #define KAI_ASM_FUNCTION_USE(name) _##name\n    #else\n        #define KAI_ASM_GLOBAL(name) .global name\n        #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n        #define KAI_ASM_FUNCTION_LABEL(name) name:\n        #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n        #define KAI_ASM_FUNCTION_USE(name) name\n    #endif\n\n    #define KAI_ASM_CODE(name) .text\n    #define KAI_ASM_ALIGN .p2align 4,,11\n    #define KAI_ASM_LABEL(name) name:\n    #define KAI_ASM_INST(hex) .inst hex\n    #define KAI_ASM_END\n#endif\n\n    KAI_ASM_CODE(kai_common)\n    KAI_ASM_ALIGN\n\n    KAI_ASM_GLOBAL(kai_get_sme_vector_length_u8)\n    KAI_ASM_GLOBAL(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_commit_za)\nKAI_ASM_FUNCTION_LABEL(kai_commit_za)\n#if defined(__ARM_FEATURE_SME)\n    stp fp, lr, [sp, #-16]!\n    mov fp, sp\n    mrs x9, TPIDR2_EL0\n    cbz x9, leave\n    bl KAI_ASM_FUNCTION_USE(__arm_tpidr2_save)\n    msr TPIDR2_EL0, xzr\nleave:\n    ldp fp, lr, [sp], #16\n#endif\n    ret\n    KAI_ASM_FUNCTION_END(kai_commit_za)\n\nKAI_ASM_FUNCTION_TYPE(kai_get_sme_vector_length_u8)\nKAI_ASM_FUNCTION_LABEL(kai_get_sme_vector_length_u8)\n    KAI_ASM_INST(0x04bf5820) // rdsvl x0, #1\n    ret\n    KAI_ASM_FUNCTION_END(kai_get_sme_vector_length_u8)\n\n    KAI_ASM_END\n"
     },
+    {
+      "path": "kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.h",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include <stddef.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif  // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme to pack the LHS matrix.\n/// -# kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme to pack the RHS matrix.\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(void);\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(void);\n\n/// Gets the offset in bytes to the data element in the packed LHS matrix buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix. Must be a multiple of `m_step`.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n    size_t m_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the offset in bytes to the data element in the packed RHS matrix buffer.\n///\n/// @param[in] n_idx Column index in the unpacked RHS matrix. Must be a multiple of `n_step`.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n    size_t n_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the offset in bytes to the data element in the destination matrix buffer.\n///\n/// @param[in] m_idx Row index. Must be a multiple of `m_step`.\n/// @param[in] n_idx Column index. Must be a multiple of `n_step`.\n/// @param[in] dst_stride_row Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_dst_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n    size_t m_idx, size_t n_idx, size_t dst_stride_row);\n\n/// Gets the size in bytes of the destination matrix buffer.\n///\n/// @param[in] m Number of rows.\n/// @param[in] n Number of columns.\n///\n/// @return The size in bytes of the destination matrix buffer.\nsize_t kai_get_dst_size_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(size_t m, size_t n);\n\n/// Runs the matrix multiplication microkernel followed by a clamp operation.\n///\n/// The pointer of each buffers (packed LHS, packed RHS and output) needs to be added with offset\n/// calculated using the following functions:\n///\n///   * Packed LHS: @ref kai_get_lhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.\n///   * Packed RHS: @ref kai_get_rhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.\n///   * Output: @ref kai_get_dst_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.\n///\n/// @param[in] m Number of output rows to be computed.\n/// @param[in] n Number of output columns to be computed.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n/// @param[in] lhs_packed Packed LHS matrix buffer.\n/// @param[in] rhs_packed Packed RHS matrix buffer.\n/// @param[out] dst Output matrix buffer.\n/// @param[in] dst_stride_row Row stride in bytes of the output matrix.\n/// @param[in] clamp_min Minimum value to clamp the final result.\n/// @param[in] clamp_max Maximum value to clamp the final result.\n///\n/// @note Clamp minimum and maximum values are cast internally to the destination type before clamping the computed\n/// values.\n///\nvoid kai_run_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n    size_t m, size_t n, size_t k_chunk_count, size_t k_chunk_length, const void* lhs_packed, const void* rhs_packed,\n    void* dst, size_t dst_stride_row, float clamp_min, float clamp_max);\n\n#ifdef __cplusplus\n}  // extern \"C\"\n#endif  // __cplusplus\n"
+    },
+    {
+      "path": "kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.c",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else  // Architectural features check.\n#include \"kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.h\"\n\n#include <stddef.h>\n#include <stdint.h>\n\n#include \"kai/kai_common.h\"\n\ntypedef struct {\n    const void* A;\n    const void* B;\n    void* C;\n    uint64_t ldcb;\n    uint64_t M;\n    uint64_t N;\n    uint64_t K;\n    float min;\n    float max;\n    void* accumulator_buffer;\n    uint64_t flags;\n} KernelArgs;\n\nstatic const size_t kai_mr = 2;\nstatic const size_t kai_nr = 2;\nstatic const size_t kai_kr = 1;\n\nvoid kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(KernelArgs* args);\n\n// Returns a constant value specific to this kernel that's relative to vector length\nstatic size_t kai_get_kernel_vec_length_constant(void) {\n    const size_t kernel_vec_length_constant = kai_get_sme_vector_length_u32() / kai_kr;\n    return kernel_vec_length_constant;\n}\n\nsize_t kai_get_m_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(void) {\n    return kai_mr * kai_get_kernel_vec_length_constant();\n}\n\nsize_t kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(void) {\n    return kai_nr * kai_get_kernel_vec_length_constant();\n}\n\nsize_t kai_get_lhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n    size_t m_idx, size_t k_chunk_count, size_t k_chunk_length) {\n    KAI_ASSUME(m_idx % kai_get_m_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa() == 0);\n    return m_idx * k_chunk_count * kai_roundup(k_chunk_length, kai_kr) * sizeof(float);\n}\n\nstatic size_t kai_get_rhs_packed_stride_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n    size_t k_chunk_count, size_t k_chunk_length) {\n    return kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa() *\n        (sizeof(float) + k_chunk_count * kai_roundup(k_chunk_length, kai_kr) * sizeof(float));\n}\n\nsize_t kai_get_rhs_packed_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n    size_t n_idx, size_t k_chunk_count, size_t k_chunk_length) {\n    KAI_ASSUME(n_idx % kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa() == 0);\n    const size_t block_idx = n_idx / kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa();\n    return block_idx *\n        kai_get_rhs_packed_stride_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n               k_chunk_count, k_chunk_length);\n}\n\nsize_t kai_get_dst_offset_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n    size_t m_idx, size_t n_idx, size_t dst_stride_row) {\n    KAI_ASSUME(m_idx % kai_get_m_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa() == 0);\n    KAI_ASSUME(n_idx % kai_get_n_step_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa() == 0);\n\n    return m_idx * dst_stride_row + n_idx * sizeof(float);\n}\n\nsize_t kai_get_dst_size_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(size_t m, size_t n) {\n    return m * n * sizeof(float);\n}\n\nvoid kai_run_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n    size_t m, size_t n, size_t k_chunk_count, size_t k_chunk_length, const void* lhs_packed, const void* rhs_packed,\n    void* dst, size_t dst_stride_row, float clamp_min, float clamp_max) {\n    KernelArgs args;\n\n    args.A = lhs_packed;\n    args.B = rhs_packed;\n    args.C = dst;\n    args.ldcb = dst_stride_row;\n    args.M = m;\n    args.N = n;\n    args.K = k_chunk_count * kai_roundup(k_chunk_length, kai_kr);\n    args.min = clamp_min;\n    args.max = clamp_max;\n    args.accumulator_buffer = NULL;\n    args.flags = 0;\n\n    kai_commit_za();\n\n    kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(&args);\n}\n\n#endif  // Architectural features check.\n"
+    },
+    {
+      "path": "kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa_asm.S",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n    #define KAI_ASM_GLOBAL(name) GLOBAL name\n    #define KAI_ASM_FUNCTION_TYPE(name)\n    #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n    #define KAI_ASM_FUNCTION_END(name) ENDP\n\n    #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n    #define KAI_ASM_ALIGN\n    #define KAI_ASM_LABEL(name) name\n    #define KAI_ASM_INST(hex) DCD hex\n    #define KAI_ASM_END END\n#else\n    #if defined(__APPLE__)\n        #define KAI_ASM_GLOBAL(name) .globl _##name\n        #define KAI_ASM_FUNCTION_TYPE(name)\n        #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n        #define KAI_ASM_FUNCTION_END(name)\n    #else\n        #define KAI_ASM_GLOBAL(name) .global name\n        #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n        #define KAI_ASM_FUNCTION_LABEL(name) name:\n        #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n    #endif\n\n    #define KAI_ASM_CODE(name) .text\n    #define KAI_ASM_ALIGN .p2align 4,,11\n    #define KAI_ASM_LABEL(name) name:\n    #define KAI_ASM_INST(hex) .inst hex\n    #define KAI_ASM_END\n#endif\n\n    KAI_ASM_CODE(imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa)\n    KAI_ASM_ALIGN\n\n    KAI_ASM_GLOBAL(kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa)\n    stp x20, x21, [sp, -144]!\n    stp x22, x23, [sp, 16]\n    stp x24, x25, [sp, 32]\n    stp x26, x27, [sp, 48]\n    str x28, [sp, 64]\n    stp d8, d9, [sp, 72]\n    stp d10, d11, [sp, 88]\n    stp d12, d13, [sp, 104]\n    stp d14, d15, [sp, 120]\n    KAI_ASM_INST(0xd503477f)  // SMSTART ZA\n    mov x15, #0x0\n    ptrue p0.b\n    KAI_ASM_INST(0x25207811)  // ptrue pn9.b\n    ldr x14, [x0, #0x30]\n    ldr w13, [x0, #0x20]\n    mov x11, #0x0\n    ldr w10, [x0, #0x28]\n    ldr x9, [x0, #0x0]\nKAI_ASM_LABEL(label_1)  // M loop\n    ldr x28, [x0, #0x8]\nKAI_ASM_LABEL(label_2)  // N loop\n    fmov z22.s, #1.0\n    KAI_ASM_INST(0xa040478c)  // ld1w { z12.s-z13.s }, pn9.b/Z, [x28]\n    KAI_ASM_INST(0xc00800ff)  // zero { zad0, zad1, zad2, zad3, zad4, zad5, zad6, zad7 }\n    mov x27, x9\n    KAI_ASM_INST(0x25aa4570)  // whilelt pn8.s, x11, x10, VLx2\n    addvl x28, x28, #2\n    KAI_ASM_INST(0x808c02c0)  // fmopa za0.s, p0/M, p0/M, z22.s, z12.s\n    KAI_ASM_INST(0x808d02c1)  // fmopa za1.s, p0/M, p0/M, z22.s, z13.s\n    KAI_ASM_INST(0x808c02c2)  // fmopa za2.s, p0/M, p0/M, z22.s, z12.s\n    KAI_ASM_INST(0x808d02c3)  // fmopa za3.s, p0/M, p0/M, z22.s, z13.s\n    lsr x21, x14, #0x2\n    and x20, x14, #0x3\n    cbz x21, label_6\n    subs x21, x21, #0x1\n    KAI_ASM_INST(0xa040c764)  // ld1w { z4.s-z7.s }, pn9.b/Z, [x27]\n    KAI_ASM_INST(0xa041c768)  // ld1w { z8.s-z11.s }, pn9.b/Z, [x27, #0x4, MUL VL]\n    addvl x27, x27, #8\n    KAI_ASM_INST(0xa040c794)  // ld1w { z20.s-z23.s }, pn9.b/Z, [x28]\n    KAI_ASM_INST(0xa041c78c)  // ld1w { z12.s-z15.s }, pn9.b/Z, [x28, #0x4, MUL VL]\n    addvl x28, x28, #8\n    ble label_5\nKAI_ASM_LABEL(label_4)  // K loop\n    KAI_ASM_INST(0x80940080)  // fmopa za0.s, p0/M, p0/M, z4.s, z20.s\n    subs x21, x21, #0x1\n    KAI_ASM_INST(0x80950081)  // fmopa za1.s, p0/M, p0/M, z4.s, z21.s\n    KAI_ASM_INST(0x809400a2)  // fmopa za2.s, p0/M, p0/M, z5.s, z20.s\n    KAI_ASM_INST(0x809500a3)  // fmopa za3.s, p0/M, p0/M, z5.s, z21.s\n    KAI_ASM_INST(0x809600c0)  // fmopa za0.s, p0/M, p0/M, z6.s, z22.s\n    KAI_ASM_INST(0x809700c1)  // fmopa za1.s, p0/M, p0/M, z6.s, z23.s\n    KAI_ASM_INST(0x809600e2)  // fmopa za2.s, p0/M, p0/M, z7.s, z22.s\n    KAI_ASM_INST(0x809700e3)  // fmopa za3.s, p0/M, p0/M, z7.s, z23.s\n    KAI_ASM_INST(0xa040c764)  // ld1w { z4.s-z7.s }, pn9.b/Z, [x27]\n    KAI_ASM_INST(0x808c0100)  // fmopa za0.s, p0/M, p0/M, z8.s, z12.s\n    KAI_ASM_INST(0xa040c794)  // ld1w { z20.s-z23.s }, pn9.b/Z, [x28]\n    KAI_ASM_INST(0x808d0101)  // fmopa za1.s, p0/M, p0/M, z8.s, z13.s\n    KAI_ASM_INST(0x808c0122)  // fmopa za2.s, p0/M, p0/M, z9.s, z12.s\n    KAI_ASM_INST(0x808d0123)  // fmopa za3.s, p0/M, p0/M, z9.s, z13.s\n    KAI_ASM_INST(0x808e0140)  // fmopa za0.s, p0/M, p0/M, z10.s, z14.s\n    KAI_ASM_INST(0x808f0141)  // fmopa za1.s, p0/M, p0/M, z10.s, z15.s\n    KAI_ASM_INST(0x808e0162)  // fmopa za2.s, p0/M, p0/M, z11.s, z14.s\n    KAI_ASM_INST(0x808f0163)  // fmopa za3.s, p0/M, p0/M, z11.s, z15.s\n    KAI_ASM_INST(0xa041c768)  // ld1w { z8.s-z11.s }, pn9.b/Z, [x27, #0x4, MUL VL]\n    addvl x27, x27, #8\n    KAI_ASM_INST(0xa041c78c)  // ld1w { z12.s-z15.s }, pn9.b/Z, [x28, #0x4, MUL VL]\n    addvl x28, x28, #8\n    bgt label_4\nKAI_ASM_LABEL(label_5)  // K loop tail\n    KAI_ASM_INST(0x80940080)  // fmopa za0.s, p0/M, p0/M, z4.s, z20.s\n    KAI_ASM_INST(0x80950081)  // fmopa za1.s, p0/M, p0/M, z4.s, z21.s\n    KAI_ASM_INST(0x809400a2)  // fmopa za2.s, p0/M, p0/M, z5.s, z20.s\n    KAI_ASM_INST(0x809500a3)  // fmopa za3.s, p0/M, p0/M, z5.s, z21.s\n    KAI_ASM_INST(0x809600c0)  // fmopa za0.s, p0/M, p0/M, z6.s, z22.s\n    KAI_ASM_INST(0x809700c1)  // fmopa za1.s, p0/M, p0/M, z6.s, z23.s\n    KAI_ASM_INST(0x809600e2)  // fmopa za2.s, p0/M, p0/M, z7.s, z22.s\n    KAI_ASM_INST(0x809700e3)  // fmopa za3.s, p0/M, p0/M, z7.s, z23.s\n    KAI_ASM_INST(0x808c0100)  // fmopa za0.s, p0/M, p0/M, z8.s, z12.s\n    KAI_ASM_INST(0x808d0101)  // fmopa za1.s, p0/M, p0/M, z8.s, z13.s\n    KAI_ASM_INST(0x808c0122)  // fmopa za2.s, p0/M, p0/M, z9.s, z12.s\n    KAI_ASM_INST(0x808d0123)  // fmopa za3.s, p0/M, p0/M, z9.s, z13.s\n    KAI_ASM_INST(0x808e0140)  // fmopa za0.s, p0/M, p0/M, z10.s, z14.s\n    KAI_ASM_INST(0x808f0141)  // fmopa za1.s, p0/M, p0/M, z10.s, z15.s\n    KAI_ASM_INST(0x808e0162)  // fmopa za2.s, p0/M, p0/M, z11.s, z14.s\n    KAI_ASM_INST(0x808f0163)  // fmopa za3.s, p0/M, p0/M, z11.s, z15.s\nKAI_ASM_LABEL(label_6)  // K oddments\n    cbz x20, label_8\nKAI_ASM_LABEL(label_7)  // K oddments: Loop\n    KAI_ASM_INST(0xa040477c)  // ld1w { z28.s-z29.s }, pn9.b/Z, [x27]\n    subs x20, x20, #0x1\n    addvl x27, x27, #2\n    KAI_ASM_INST(0xa1404787)  // ld1w { z7.s, z15.s }, pn9.b/Z, [x28]\n    addvl x28, x28, #2\n    KAI_ASM_INST(0x80870380)  // fmopa za0.s, p0/M, p0/M, z28.s, z7.s\n    KAI_ASM_INST(0x808f0381)  // fmopa za1.s, p0/M, p0/M, z28.s, z15.s\n    KAI_ASM_INST(0x808703a2)  // fmopa za2.s, p0/M, p0/M, z29.s, z7.s\n    KAI_ASM_INST(0x808f03a3)  // fmopa za3.s, p0/M, p0/M, z29.s, z15.s\n    bgt label_7\nKAI_ASM_LABEL(label_8)  // K oddments: End\n    ldr x26, [x0, #0x10]\n    sub x25, x13, x15\n    cntw x24\n    KAI_ASM_INST(0x854ec01a)  // ld1rw { z26.s }, p0/Z, [x0, #56]\n    ldr x23, [x0, #0x18]\n    cmp x25, x24\n    KAI_ASM_INST(0x854fc018)  // ld1rw { z24.s }, p0/Z, [x0, #60]\n    mov x12, #0x0\n    csel x22, x25, x24, LT\n    add x26, x26, x11, LSL #2  // C += n\n    lsr x21, x22, #0x2\n    madd x26, x15, x23, x26  // C += m * ldc\n    and x20, x22, #0x3\n    cbz x21, label_11\nKAI_ASM_LABEL(label_10)  // Store to output array: Accumulator row 0 loop\n    KAI_ASM_INST(0xc0860404)  // mova { z4.s-z7.s }, za0h.s[x12]\n    KAI_ASM_INST(0xc086042c)  // mova { z12.s-z15.s }, za1h.s[x12]\n    KAI_ASM_INST(0xc1b8cb44)  // fclamp { z4.s-z7.s }, z26.s, z24.s\n    KAI_ASM_INST(0xc1b8cb4c)  // fclamp { z12.s-z15.s }, z26.s, z24.s\n    add x12, x12, #0x4\n    cmp x12, x21, LSL #2\n    KAI_ASM_INST(0xa1604344)  // st1w { z4.s, z12.s }, p8, [x26]\n    add x26, x26, x23\n    KAI_ASM_INST(0xa1604345)  // st1w { z5.s, z13.s }, p8, [x26]\n    add x26, x26, x23\n    KAI_ASM_INST(0xa1604346)  // st1w { z6.s, z14.s }, p8, [x26]\n    add x26, x26, x23\n    KAI_ASM_INST(0xa1604347)  // st1w { z7.s, z15.s }, p8, [x26]\n    add x26, x26, x23\n    blt label_10\nKAI_ASM_LABEL(label_11)  // Store to output array: Accumulator row 0 oddments\n    cbz x20, label_12\n    KAI_ASM_INST(0xc0860400)  // mova { z0.s-z3.s }, za0h.s[x12]\n    KAI_ASM_INST(0xc0860428)  // mova { z8.s-z11.s }, za1h.s[x12]\n    subs x20, x20, #0x1\n    KAI_ASM_INST(0xc1b8cb40)  // fclamp { z0.s-z3.s }, z26.s, z24.s\n    KAI_ASM_INST(0xc1b8cb48)  // fclamp { z8.s-z11.s }, z26.s, z24.s\n    KAI_ASM_INST(0xa1604340)  // st1w { z0.s, z8.s }, p8, [x26]\n    add x26, x26, x23\n    beq label_12\n    subs x20, x20, #0x1\n    KAI_ASM_INST(0xa1604341)  // st1w { z1.s, z9.s }, p8, [x26]\n    add x26, x26, x23\n    beq label_12\n    KAI_ASM_INST(0xa1604342)  // st1w { z2.s, z10.s }, p8, [x26]\n    add x26, x26, x23\nKAI_ASM_LABEL(label_12)  // Store to output array: Accumulator row 0 oddments: End\n    subs x25, x25, x22\n    beq label_16\n    cmp x25, x24\n    mov x12, #0x0\n    csel x20, x25, x24, LT\n    lsr x21, x20, #0x2\n    and x20, x20, #0x3\n    cbz x21, label_14\nKAI_ASM_LABEL(label_13)  // Store to output array: Accumulator row 1 loop\n    KAI_ASM_INST(0xc0860454)  // mova { z20.s-z23.s }, za2h.s[x12]\n    KAI_ASM_INST(0xc086047c)  // mova { z28.s-z31.s }, za3h.s[x12]\n    KAI_ASM_INST(0xc1b8cb54)  // fclamp { z20.s-z23.s }, z26.s, z24.s\n    KAI_ASM_INST(0xc1b8cb5c)  // fclamp { z28.s-z31.s }, z26.s, z24.s\n    add x12, x12, #0x4\n    cmp x12, x21, LSL #2\n    KAI_ASM_INST(0xa1604354)  // st1w { z20.s, z28.s }, p8, [x26]\n    add x26, x26, x23\n    KAI_ASM_INST(0xa1604355)  // st1w { z21.s, z29.s }, p8, [x26]\n    add x26, x26, x23\n    KAI_ASM_INST(0xa1604356)  // st1w { z22.s, z30.s }, p8, [x26]\n    add x26, x26, x23\n    KAI_ASM_INST(0xa1604357)  // st1w { z23.s, z31.s }, p8, [x26]\n    add x26, x26, x23\n    blt label_13\nKAI_ASM_LABEL(label_14)  // Store to output array: Accumulator row 1 oddments\n    cbz x20, label_15\n    KAI_ASM_INST(0xc0860444)  // mova { z4.s-z7.s }, za2h.s[x12]\n    KAI_ASM_INST(0xc086046c)  // mova { z12.s-z15.s }, za3h.s[x12]\n    subs x20, x20, #0x1\n    KAI_ASM_INST(0xc1b8cb44)  // fclamp { z4.s-z7.s }, z26.s, z24.s\n    KAI_ASM_INST(0xc1b8cb4c)  // fclamp { z12.s-z15.s }, z26.s, z24.s\n    KAI_ASM_INST(0xa1604344)  // st1w { z4.s, z12.s }, p8, [x26]\n    add x26, x26, x23\n    beq label_15\n    subs x20, x20, #0x1\n    KAI_ASM_INST(0xa1604345)  // st1w { z5.s, z13.s }, p8, [x26]\n    add x26, x26, x23\n    beq label_15\n    KAI_ASM_INST(0xa1604346)  // st1w { z6.s, z14.s }, p8, [x26]\nKAI_ASM_LABEL(label_15)  // Store to output array: Accumulator row 1 oddments: End\nKAI_ASM_LABEL(label_16)  // Store to output array: End\n    incw x11, ALL, MUL #2\n    cmp x11, x10\n    blt label_2\n    incw x15, ALL, MUL #2\n    mov x11, #0x0\n    cmp x15, x13\n    mov x9, x27\n    blt label_1\n    KAI_ASM_INST(0xd503467f)  // SMSTOP\n    ldp x22, x23, [sp, 16]\n    ldp x24, x25, [sp, 32]\n    ldp x26, x27, [sp, 48]\n    ldr x28, [sp, 64]\n    ldp d8, d9, [sp, 72]\n    ldp d10, d11, [sp, 88]\n    ldp d12, d13, [sp, 104]\n    ldp d14, d15, [sp, 120]\n    ldp x20, x21, [sp], 144\n    ret\n    KAI_ASM_FUNCTION_END(kai_kernel_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa)\n\n    KAI_ASM_END\n"
+    },
+    {
+      "path": "kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme.h",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include <stddef.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif  // __cplusplus\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_lhs_imatmul_pack_x32p2vlx1_x32p_sme(void);\n\n/// Gets the offset in bytes to the data element in the packed LHS buffer.\n///\n/// @param[in] m_idx Row index in the unpacked LHS matrix.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_packed_offset_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n    size_t m_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the size in bytes of the packed LHS buffer.\n///\n/// @param[in] m Number of rows in the unpacked LHS matrix.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n///\n/// @return The size in bytes of the packed LHS buffer.\nsize_t kai_get_lhs_packed_size_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n    size_t m, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Pack the LHS matrix for use with indirect matrix multiplication\n///\n/// @param[in] m Number of rows of the unpacked LHS matrix.\n/// @param[in] k_chunk_count Number of LHS column splits.\n/// @param[in] k_chunk_length Length of a LHS column split.\n/// @param[in] lhs_ptrs Pointer to an array of input pointers consisting of\n///            `roundup(m, m_step) * k_chunk_count` pointers. The pointers are\n///            grouped in blocks of `m_step` rows and `k_chunk_count` columns.\n///            Within each block, the pointers are stored in column-major order.\n/// @param[in] lhs_ptr_offset Offset to add to each pointer of the @ref lhs_ptrs\n///            array, excluding zero pointers.\n/// @param[in] pad_ptr Pointer to chunk used for padding. @ref lhs_ptr_offset is\n///            not applied to this pointer when used in @ref lhs_ptrs. This can\n///            be NULL if there is no padding used @ref lhs_ptrs\n/// @param[out] lhs_packed Packed LHS matrix.\nvoid kai_run_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n    size_t m, size_t k_chunk_count, size_t k_chunk_length, const void* const* lhs_ptrs, size_t lhs_ptr_offset,\n    const void* pad_ptr, void* lhs_packed);\n\n#ifdef __cplusplus\n}  // extern \"C\"\n#endif  // __cplusplus\n"
+    },
+    {
+      "path": "kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme.c",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025-2026 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else  // Architectural features check.\n#include \"kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme.h\"\n\n#include <stddef.h>\n#include <stdint.h>\n\n#include \"kai/kai_common.h\"\n\nenum {\n    MR = 2,\n    KR = 1,\n    MAX_M_STEP = MR * (KAI_SME_VEC_LENGTH_MAX_BYTES / sizeof(float)) / KR,\n};\n\nvoid kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme(size_t height, size_t width, const void* in, void* out);\n\nstatic size_t kai_get_mr_lhs_imatmul_pack_x32p2vlx1_x32p_sme(void) {\n    return MR * kai_get_sme_vector_length_u32() / KR;\n}\n\nsize_t kai_get_m_step_lhs_imatmul_pack_x32p2vlx1_x32p_sme(void) {\n    return kai_get_mr_lhs_imatmul_pack_x32p2vlx1_x32p_sme();\n}\n\nsize_t kai_get_lhs_packed_offset_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n    size_t m_idx, size_t k_chunk_count, size_t k_chunk_length) {\n    KAI_ASSUME(m_idx % kai_get_m_step_lhs_imatmul_pack_x32p2vlx1_x32p_sme() == 0);\n\n    return m_idx * k_chunk_count * kai_roundup(k_chunk_length, KR) * sizeof(float);\n}\n\nsize_t kai_get_lhs_packed_size_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n    size_t m, size_t k_chunk_count, size_t k_chunk_length) {\n    const size_t m_end = kai_roundup(m, kai_get_mr_lhs_imatmul_pack_x32p2vlx1_x32p_sme());\n    return kai_get_lhs_packed_offset_lhs_imatmul_pack_x32p2vlx1_x32p_sme(m_end, k_chunk_count, k_chunk_length);\n}\n\nvoid kai_run_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n    size_t m, size_t k_chunk_count, size_t k_chunk_length, const void* const* lhs_ptrs, size_t lhs_ptr_offset,\n    const void* pad_ptr, void* lhs_packed) {\n    KAI_ASSUME(lhs_ptrs != NULL);\n    KAI_ASSUME(lhs_packed != NULL);\n\n    const size_t m_step = kai_get_mr_lhs_imatmul_pack_x32p2vlx1_x32p_sme();\n    const size_t table_size = kai_roundup(m, m_step) * k_chunk_count;\n    const size_t width = k_chunk_length;\n\n    KAI_ASSERT(m_step <= MAX_M_STEP);\n    const uint8_t* in[MAX_M_STEP];\n\n    uint8_t* out_base = lhs_packed;\n\n    kai_commit_za();\n\n    for (size_t i_m = 0; i_m < m; i_m += m_step) {\n        for (size_t i_k_chunk = 0; i_k_chunk < k_chunk_count; i_k_chunk += 1) {\n            const size_t height = KAI_MIN(m - i_m, m_step);\n            void* out = out_base;\n            out_base += m_step * kai_roundup(k_chunk_length, KR) * sizeof(float);\n            for (size_t y = 0; y < height; y += 1) {\n                const size_t lhs_ptr_idx = i_m * k_chunk_count + i_k_chunk * m_step + y;\n                KAI_ASSERT(lhs_ptr_idx < table_size);\n                in[y] = lhs_ptrs[lhs_ptr_idx];\n                if (in[y] != pad_ptr) {\n                    uintptr_t in_ptr = (uintptr_t)in[y] + lhs_ptr_offset;\n                    in[y] = (const uint8_t*)in_ptr;  // NOLINT(performance-no-int-to-ptr)\n                }\n            }\n\n            // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion)\n            kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme(height, width, in, out);\n        }\n    }\n}\n\n#endif  // Architectural features check.\n"
+    },
+    {
+      "path": "kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme_asm.S",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n    #define KAI_ASM_GLOBAL(name) GLOBAL name\n    #define KAI_ASM_FUNCTION_TYPE(name)\n    #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n    #define KAI_ASM_FUNCTION_END(name) ENDP\n\n    #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n    #define KAI_ASM_ALIGN\n    #define KAI_ASM_LABEL(name) name\n    #define KAI_ASM_INST(hex) DCD hex\n    #define KAI_ASM_END END\n#else\n    #if defined(__APPLE__)\n        #define KAI_ASM_GLOBAL(name) .globl _##name\n        #define KAI_ASM_FUNCTION_TYPE(name)\n        #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n        #define KAI_ASM_FUNCTION_END(name)\n    #else\n        #define KAI_ASM_GLOBAL(name) .global name\n        #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n        #define KAI_ASM_FUNCTION_LABEL(name) name:\n        #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n    #endif\n\n    #define KAI_ASM_CODE(name) .text\n    #define KAI_ASM_ALIGN .p2align 4,,11\n    #define KAI_ASM_LABEL(name) name:\n    #define KAI_ASM_INST(hex) .inst hex\n    #define KAI_ASM_END\n#endif\n\n    KAI_ASM_CODE(lhs_imatmul_pack_x32p2vlx1_x32p_sme)\n    KAI_ASM_ALIGN\n\n    KAI_ASM_GLOBAL(kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme)\n    stp x20, x21, [sp, -144]!\n    stp x22, x23, [sp, 16]\n    stp x24, x25, [sp, 32]\n    stp x26, x27, [sp, 48]\n    str x28, [sp, 64]\n    stp d8, d9, [sp, 72]\n    stp d10, d11, [sp, 88]\n    stp d12, d13, [sp, 104]\n    stp d14, d15, [sp, 120]\n    KAI_ASM_INST(0xd503477f)  // SMSTART ZA\n    mov x22, #0x0\n    mov x21, x1\n    cntw x16\n    incw x21\n    mov x20, x1\n    sub x21, x21, #0x1\n    sub x15, x16, #0x1\n    udiv x21, x21, x16  // n_passes = ceildiv(width, VL<T>)\n    ands x15, x20, x15\n    sub x20, x21, #0x1\n    sub x14, x16, #0x2\n    mov x11, #0x0\n    mov x10, x2\n    add x9, x2, x16, LSL #3\n    cntw x28, ALL, MUL #2\n    ldr x27, [x10, #0x0]\n    cntw x26, ALL, MUL #3\n    lsr x20, x20, #0x1  // n_loops = (n_passes - 1) / 2\n    ldr x25, [x9, #0x0]\n    and x24, x21, #0x1  // odd_tail = bool(n_passes & 0x1)\n    csel x15, x15, x16, NE\n    ldr x23, [x10, #0x8]\n    ptrue p12.s\n    whilelt p11.s, XZR, x0\n    ldr x21, [x9, #0x8]\n    whilelt p10.s, x16, x0\n    mov x22, x22\n    whilelt p9.s, x11, x1\n    whilelt p8.s, x11, x1\n    add x10, x10, #0x10\n    add x9, x9, #0x10\n    mov x12, #0x0\n    cbz x14, label_2\nKAI_ASM_LABEL(label_1)  // K loop: Charge: Loop\n    KAI_ASM_INST(0x25306163)  // psel p3.s, p8.s/Z, p11.s[w12]\n    KAI_ASM_INST(0x25306142)  // psel p2.s, p8.s/Z, p10.s[w12]\n    KAI_ASM_INST(0x25706161)  // psel p1.s, p8.s/Z, p11.s[w12, #1]\n    KAI_ASM_INST(0x25706140)  // psel p0.s, p8.s/Z, p10.s[w12, #1]\n    KAI_ASM_INST(0xe0960f60)  // ld1w { za0h.s[x12] }, p3/Z, [x27, x22, LSL #2]\n    ldr x27, [x10, #0x0]\n    KAI_ASM_INST(0xe0960b24)  // ld1w { za1h.s[x12] }, p2/Z, [x25, x22, LSL #2]\n    ldr x25, [x9, #0x0]\n    KAI_ASM_INST(0xe09606e1)  // ld1w { za0h.s[x12, #1] }, p1/Z, [x23, x22, LSL #2]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe09602a5)  // ld1w { za1h.s[x12, #1] }, p0/Z, [x21, x22, LSL #2]\n    add x12, x12, #0x2\n    ldr x21, [x9, #0x8]\n    add x9, x9, #0x10\n    cmp x12, x14\n    blt label_1\nKAI_ASM_LABEL(label_2)  // K loop: Charge: End\n    KAI_ASM_INST(0x25306163)  // psel p3.s, p8.s/Z, p11.s[w12]\n    KAI_ASM_INST(0x25306142)  // psel p2.s, p8.s/Z, p10.s[w12]\n    KAI_ASM_INST(0x25706161)  // psel p1.s, p8.s/Z, p11.s[w12, #1]\n    KAI_ASM_INST(0x25706140)  // psel p0.s, p8.s/Z, p10.s[w12, #1]\n    mov x10, x2\n    add x9, x2, x16, LSL #3\n    KAI_ASM_INST(0xe0960f60)  // ld1w { za0h.s[x12] }, p3/Z, [x27, x22, LSL #2]\n    ldr x27, [x10, #0x0]\n    incw x11\n    KAI_ASM_INST(0xe0960b24)  // ld1w { za1h.s[x12] }, p2/Z, [x25, x22, LSL #2]\n    ldr x25, [x9, #0x0]\n    KAI_ASM_INST(0xe09606e1)  // ld1w { za0h.s[x12, #1] }, p1/Z, [x23, x22, LSL #2]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe09602a5)  // ld1w { za1h.s[x12, #1] }, p0/Z, [x21, x22, LSL #2]\n    ldr x21, [x9, #0x8]\n    add x9, x9, #0x10\n    incw x22\n    cbz x20, label_8\n    mov x20, x20\nKAI_ASM_LABEL(label_3)  // K loop: Main loop\n    whilelt p8.s, x11, x1\n    mov x13, #0x0\n    cbz x14, label_5\nKAI_ASM_LABEL(label_4)  // K loop: Main loop: First: Loop\n    KAI_ASM_INST(0x25316160)  // psel p0.s, p8.s/Z, p11.s[w13]\n    KAI_ASM_INST(0x25316142)  // psel p2.s, p8.s/Z, p10.s[w13]\n    KAI_ASM_INST(0x25716161)  // psel p1.s, p8.s/Z, p11.s[w13, #1]\n    KAI_ASM_INST(0x25716143)  // psel p3.s, p8.s/Z, p10.s[w13, #1]\n    KAI_ASM_INST(0xe0962368)  // ld1w { za2h.s[x13] }, p0/Z, [x27, x22, LSL #2]\n    KAI_ASM_INST(0x25317120)  // psel p0.s, p12.s/Z, p9.s[w13]\n    ldr x27, [x10, #0x0]\n    KAI_ASM_INST(0xe0962b2c)  // ld1w { za3h.s[x13] }, p2/Z, [x25, x22, LSL #2]\n    KAI_ASM_INST(0x25317122)  // psel p2.s, p12.s/Z, p9.s[w13]\n    ldr x25, [x9, #0x0]\n    KAI_ASM_INST(0xe09626e9)  // ld1w { za2h.s[x13, #1] }, p1/Z, [x23, x22, LSL #2]\n    KAI_ASM_INST(0x25717121)  // psel p1.s, p12.s/Z, p9.s[w13, #1]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe0962ead)  // ld1w { za3h.s[x13, #1] }, p3/Z, [x21, x22, LSL #2]\n    ldr x21, [x9, #0x8]\n    KAI_ASM_INST(0xe0bfa060)  // st1w { za0v.s[x13] }, p0/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0x25717120)  // psel p0.s, p12.s/Z, p9.s[w13, #1]\n    KAI_ASM_INST(0xe0b0a864)  // st1w { za1v.s[x13] }, p2/Z, [x3, x16, LSL #2]\n    add x9, x9, #0x10\n    KAI_ASM_INST(0xe0bca461)  // st1w { za0v.s[x13, #1] }, p1/Z, [x3, x28, LSL #2]\n    KAI_ASM_INST(0xe0baa065)  // st1w { za1v.s[x13, #1] }, p0/Z, [x3, x26, LSL #2]\n    add x13, x13, #0x2\n    addvl x3, x3, #4\n    cmp x13, x14\n    blt label_4\nKAI_ASM_LABEL(label_5)  // K loop: Main loop: First: Tail\n    KAI_ASM_INST(0x25316160)  // psel p0.s, p8.s/Z, p11.s[w13]\n    KAI_ASM_INST(0x25316142)  // psel p2.s, p8.s/Z, p10.s[w13]\n    KAI_ASM_INST(0x25716161)  // psel p1.s, p8.s/Z, p11.s[w13, #1]\n    KAI_ASM_INST(0x25716143)  // psel p3.s, p8.s/Z, p10.s[w13, #1]\n    mov x10, x2\n    add x9, x2, x16, LSL #3\n    KAI_ASM_INST(0xe0962368)  // ld1w { za2h.s[x13] }, p0/Z, [x27, x22, LSL #2]\n    KAI_ASM_INST(0x25317120)  // psel p0.s, p12.s/Z, p9.s[w13]\n    ldr x27, [x10, #0x0]\n    mov x12, #0x0\n    KAI_ASM_INST(0xe0962b2c)  // ld1w { za3h.s[x13] }, p2/Z, [x25, x22, LSL #2]\n    KAI_ASM_INST(0x25317122)  // psel p2.s, p12.s/Z, p9.s[w13]\n    ldr x25, [x9, #0x0]\n    KAI_ASM_INST(0xe09626e9)  // ld1w { za2h.s[x13, #1] }, p1/Z, [x23, x22, LSL #2]\n    KAI_ASM_INST(0x25717121)  // psel p1.s, p12.s/Z, p9.s[w13, #1]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe0962ead)  // ld1w { za3h.s[x13, #1] }, p3/Z, [x21, x22, LSL #2]\n    ldr x21, [x9, #0x8]\n    KAI_ASM_INST(0xe0bfa060)  // st1w { za0v.s[x13] }, p0/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0x25717120)  // psel p0.s, p12.s/Z, p9.s[w13, #1]\n    KAI_ASM_INST(0xe0b0a864)  // st1w { za1v.s[x13] }, p2/Z, [x3, x16, LSL #2]\n    whilelt p9.s, x11, x1\n    incw x11\n    KAI_ASM_INST(0xe0bca461)  // st1w { za0v.s[x13, #1] }, p1/Z, [x3, x28, LSL #2]\n    add x9, x9, #0x10\n    incw x22\n    KAI_ASM_INST(0xe0baa065)  // st1w { za1v.s[x13, #1] }, p0/Z, [x3, x26, LSL #2]\n    addvl x3, x3, #4\n    whilelt p8.s, x11, x1\n    cbz x14, label_7\nKAI_ASM_LABEL(label_6)  // K loop: Main loop: Second: Loop\n    KAI_ASM_INST(0x25306160)  // psel p0.s, p8.s/Z, p11.s[w12]\n    KAI_ASM_INST(0x25306142)  // psel p2.s, p8.s/Z, p10.s[w12]\n    KAI_ASM_INST(0x25706161)  // psel p1.s, p8.s/Z, p11.s[w12, #1]\n    KAI_ASM_INST(0x25706143)  // psel p3.s, p8.s/Z, p10.s[w12, #1]\n    KAI_ASM_INST(0xe0960360)  // ld1w { za0h.s[x12] }, p0/Z, [x27, x22, LSL #2]\n    KAI_ASM_INST(0x25307120)  // psel p0.s, p12.s/Z, p9.s[w12]\n    ldr x27, [x10, #0x0]\n    KAI_ASM_INST(0xe0960b24)  // ld1w { za1h.s[x12] }, p2/Z, [x25, x22, LSL #2]\n    KAI_ASM_INST(0x25307122)  // psel p2.s, p12.s/Z, p9.s[w12]\n    ldr x25, [x9, #0x0]\n    KAI_ASM_INST(0xe09606e1)  // ld1w { za0h.s[x12, #1] }, p1/Z, [x23, x22, LSL #2]\n    KAI_ASM_INST(0x25707121)  // psel p1.s, p12.s/Z, p9.s[w12, #1]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe0960ea5)  // ld1w { za1h.s[x12, #1] }, p3/Z, [x21, x22, LSL #2]\n    ldr x21, [x9, #0x8]\n    KAI_ASM_INST(0xe0bf8068)  // st1w { za2v.s[x12] }, p0/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0x25707120)  // psel p0.s, p12.s/Z, p9.s[w12, #1]\n    KAI_ASM_INST(0xe0b0886c)  // st1w { za3v.s[x12] }, p2/Z, [x3, x16, LSL #2]\n    add x9, x9, #0x10\n    KAI_ASM_INST(0xe0bc8469)  // st1w { za2v.s[x12, #1] }, p1/Z, [x3, x28, LSL #2]\n    KAI_ASM_INST(0xe0ba806d)  // st1w { za3v.s[x12, #1] }, p0/Z, [x3, x26, LSL #2]\n    add x12, x12, #0x2\n    addvl x3, x3, #4\n    cmp x12, x14\n    blt label_6\nKAI_ASM_LABEL(label_7)  // K loop: Main loop: Second: Tail\n    KAI_ASM_INST(0x25306160)  // psel p0.s, p8.s/Z, p11.s[w12]\n    KAI_ASM_INST(0x25306142)  // psel p2.s, p8.s/Z, p10.s[w12]\n    KAI_ASM_INST(0x25706161)  // psel p1.s, p8.s/Z, p11.s[w12, #1]\n    KAI_ASM_INST(0x25706143)  // psel p3.s, p8.s/Z, p10.s[w12, #1]\n    mov x10, x2\n    add x9, x2, x16, LSL #3\n    KAI_ASM_INST(0xe0960360)  // ld1w { za0h.s[x12] }, p0/Z, [x27, x22, LSL #2]\n    KAI_ASM_INST(0x25307120)  // psel p0.s, p12.s/Z, p9.s[w12]\n    ldr x27, [x10, #0x0]\n    KAI_ASM_INST(0xe0960b24)  // ld1w { za1h.s[x12] }, p2/Z, [x25, x22, LSL #2]\n    KAI_ASM_INST(0x25307122)  // psel p2.s, p12.s/Z, p9.s[w12]\n    ldr x25, [x9, #0x0]\n    KAI_ASM_INST(0xe09606e1)  // ld1w { za0h.s[x12, #1] }, p1/Z, [x23, x22, LSL #2]\n    KAI_ASM_INST(0x25707121)  // psel p1.s, p12.s/Z, p9.s[w12, #1]\n    ldr x23, [x10, #0x8]\n    add x10, x10, #0x10\n    KAI_ASM_INST(0xe0960ea5)  // ld1w { za1h.s[x12, #1] }, p3/Z, [x21, x22, LSL #2]\n    ldr x21, [x9, #0x8]\n    KAI_ASM_INST(0xe0bf8068)  // st1w { za2v.s[x12] }, p0/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0x25707120)  // psel p0.s, p12.s/Z, p9.s[w12, #1]\n    KAI_ASM_INST(0xe0b0886c)  // st1w { za3v.s[x12] }, p2/Z, [x3, x16, LSL #2]\n    whilelt p9.s, x11, x1\n    subs x20, x20, #0x1\n    KAI_ASM_INST(0xe0bc8469)  // st1w { za2v.s[x12, #1] }, p1/Z, [x3, x28, LSL #2]\n    add x9, x9, #0x10\n    incw x11\n    KAI_ASM_INST(0xe0ba806d)  // st1w { za3v.s[x12, #1] }, p0/Z, [x3, x26, LSL #2]\n    addvl x3, x3, #4\n    incw x22\n    bgt label_3\nKAI_ASM_LABEL(label_8)  // K loop: Tails\n    cbnz x24, label_11\n    mov x10, x2\n    whilelt p8.s, x11, x1\n    mov x12, #0x0\nKAI_ASM_LABEL(label_9)  // K loop: Tails: Even: First\n    KAI_ASM_INST(0x25307123)  // psel p3.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0x25307122)  // psel p2.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0x25306161)  // psel p1.s, p8.s/Z, p11.s[w12]\n    KAI_ASM_INST(0x25306140)  // psel p0.s, p8.s/Z, p10.s[w12]\n    KAI_ASM_INST(0xe0bf8c60)  // st1w { za0v.s[x12] }, p3/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0xe0b08864)  // st1w { za1v.s[x12] }, p2/Z, [x3, x16, LSL #2]\n    addvl x3, x3, #2\n    ldr x21, [x10, #0x0]\n    ldr x20, [x10, x16, LSL #0x3]\n    add x10, x10, #0x8\n    KAI_ASM_INST(0xe09606a8)  // ld1w { za2h.s[x12] }, p1/Z, [x21, x22, LSL #2]\n    KAI_ASM_INST(0xe096028c)  // ld1w { za3h.s[x12] }, p0/Z, [x20, x22, LSL #2]\n    add x12, x12, #0x1\n    cmp x12, x16\n    blt label_9\n    whilelt p9.s, x11, x1\n    whilelt p8.s, x11, x1\n    mov x12, #0x0\nKAI_ASM_LABEL(label_10)  // K loop: Tails: Even: Second\n    KAI_ASM_INST(0x25307121)  // psel p1.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0x25307120)  // psel p0.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0xe0bf8468)  // st1w { za2v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0xe0b0806c)  // st1w { za3v.s[x12] }, p0/Z, [x3, x16, LSL #2]\n    add x12, x12, #0x1\n    addvl x3, x3, #2\n    cmp x12, x15\n    blt label_10\n    whilelt p8.s, x11, x1\n    b label_13\nKAI_ASM_LABEL(label_11)  // K loop: Tails: Odd\n    mov x12, #0x0\nKAI_ASM_LABEL(label_12)  // K loop: Tails: Odd: Loop\n    KAI_ASM_INST(0x25307121)  // psel p1.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0x25307120)  // psel p0.s, p12.s/Z, p9.s[w12]\n    KAI_ASM_INST(0xe0bf8460)  // st1w { za0v.s[x12] }, p1/Z, [x3, XZR, LSL #2]\n    KAI_ASM_INST(0xe0b08064)  // st1w { za1v.s[x12] }, p0/Z, [x3, x16, LSL #2]\n    add x12, x12, #0x1\n    addvl x3, x3, #2\n    cmp x12, x15\n    blt label_12\nKAI_ASM_LABEL(label_13)  // K loop: End\n    KAI_ASM_INST(0xd503467f)  // SMSTOP\n    ldp x22, x23, [sp, 16]\n    ldp x24, x25, [sp, 32]\n    ldp x26, x27, [sp, 48]\n    ldr x28, [sp, 64]\n    ldp d8, d9, [sp, 72]\n    ldp d10, d11, [sp, 88]\n    ldp d12, d13, [sp, 104]\n    ldp d14, d15, [sp, 120]\n    ldp x20, x21, [sp], 144\n    ret\n    KAI_ASM_FUNCTION_END(kai_kernel_lhs_imatmul_pack_x32p2vlx1_x32p_sme)\n\n    KAI_ASM_END\n"
+    },
+    {
+      "path": "kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.h",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include <stddef.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif  // __cplusplus\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(void);\n\n/// Gets the offset in bytes to the data element in the RHS matrix buffer.\n///\n/// @param[in] n_idx Column index. Must be divisible by `n_step`\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(size_t n_idx);\n\n/// Gets the offset in bytes to the data element in the bias buffer.\n///\n/// @param[in] n_idx Column index.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_bias_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(size_t n_idx);\n\n/// Gets row stride in bytes of the packed RHS matrix.\n///\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n///\n/// @return Row stride in bytes.\nsize_t kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n    size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the offset in bytes to the data element in the packed RHS buffer.\n///\n/// @param[in] n_idx Column index. Must be divisible by `n_step`\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n    size_t n_idx, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Gets the size in bytes of the packed RHS buffer.\n///\n/// @param[in] n Number of columns.\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n///\n/// @return The size in bytes of the packed RHS buffer.\nsize_t kai_get_rhs_packed_size_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n    size_t n, size_t k_chunk_count, size_t k_chunk_length);\n\n/// Runs the RHS packing function for matrix multiplication.\n///\n/// The pointer of each buffer (RHS, bias and packed RHS) needs to be added with offset\n/// calculated using the following functions:\n///\n///   * RHS: @ref kai_get_rhs_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.\n///   * Bias: @ref kai_get_bias_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.\n///   * Output: @ref kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.\n///\n/// @param[in] n Number of columns of the output matrix.\n/// @param[in] k_chunk_count Number of chunks.\n/// @param[in] k_chunk_length Number of rows in each chunk.\n/// @param[in] rhs_stride_row Row stride in bytes of the RHS matrix.\n/// @param[in] rhs RHS matrix data buffer.\n/// @param[in] bias Bias matrix data buffer.\n/// @param[out] rhs_packed Packed RHS matrix.\nvoid kai_run_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n    size_t n, size_t k_chunk_count, size_t k_chunk_length, size_t rhs_stride_row, const void* rhs, const void* bias,\n    void* rhs_packed);\n\n#ifdef __cplusplus\n}  // extern \"C\"\n#endif  // __cplusplus\n"
+    },
+    {
+      "path": "kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.c",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if (!defined(__aarch64__) || !defined(__ARM_FEATURE_SVE2)) && !defined(_M_ARM64)\n#error This file must be compiled for AArch64, FEAT_SVE2.\n#else  // Architectural features check.\n\n#include \"kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.h\"\n\n#include <stddef.h>\n#include <stdint.h>\n\n#include \"kai/kai_common.h\"\n\nenum {\n    NR = 2,\n    KR = 1,\n};\n\ntypedef struct {\n    const void* bias_ptr;\n    size_t width;\n    size_t height;\n    size_t k_chunk_count;\n    size_t in_stride;\n    size_t out_stride;\n    const void* in;\n    void* out;\n} KernelArgs;\n\nstatic const size_t kai_num_bytes_input = sizeof(uint32_t);\nstatic const size_t kai_num_bytes_output = sizeof(uint32_t);\nstatic const size_t kai_num_bytes_bias = sizeof(float);\n\nvoid kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(const KernelArgs* args_ptr);\n\nsize_t kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(void) {\n    return NR * kai_get_sme_vector_length_u32() / KR;\n}\n\nsize_t kai_get_rhs_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(size_t n_idx) {\n    KAI_ASSUME(n_idx % kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme() == 0);\n\n    return n_idx * kai_num_bytes_input;\n}\n\nsize_t kai_get_bias_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(size_t n_idx) {\n    return n_idx * kai_num_bytes_bias;\n}\n\nsize_t kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n    size_t k_chunk_count, size_t k_chunk_length) {\n    return kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme() *\n        (kai_num_bytes_bias + k_chunk_count * kai_roundup(k_chunk_length, KR) * kai_num_bytes_output);\n}\n\nsize_t kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n    size_t n_idx, size_t k_chunk_count, size_t k_chunk_length) {\n    KAI_ASSUME(n_idx % kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme() == 0);\n\n    const size_t block_idx = n_idx / kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme();\n    return block_idx *\n        kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(k_chunk_count, k_chunk_length);\n}\n\nsize_t kai_get_rhs_packed_size_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n    size_t n, size_t k_chunk_count, size_t k_chunk_length) {\n    const size_t n_nr_blocks = kai_roundup(n, kai_get_n_step_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme());\n    return kai_get_rhs_packed_offset_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n        n_nr_blocks, k_chunk_count, k_chunk_length);\n}\n\nvoid kai_run_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n    size_t n, size_t k_chunk_count, size_t k_chunk_length, size_t rhs_stride_row, const void* rhs, const void* bias,\n    void* rhs_packed) {\n    KAI_ASSUME(rhs != NULL);\n    KAI_ASSUME(bias != NULL);\n    KAI_ASSUME(rhs_packed != NULL);\n\n    KernelArgs args;\n    args.bias_ptr = bias;\n    args.height = k_chunk_length;\n    args.width = n;\n    args.in = rhs;\n    args.out = rhs_packed;\n    args.k_chunk_count = k_chunk_count;\n    args.in_stride = rhs_stride_row;\n    args.out_stride =\n        kai_get_rhs_packed_stride_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(k_chunk_count, k_chunk_length);\n\n    kai_commit_za();\n\n    kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(&args);\n}\n\n#endif  // Architectural features check.\n"
+    },
+    {
+      "path": "kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme_asm.S",
+      "content": "//\n// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#if defined(_MSC_VER)\n    #define KAI_ASM_GLOBAL(name) GLOBAL name\n    #define KAI_ASM_FUNCTION_TYPE(name)\n    #define KAI_ASM_FUNCTION_LABEL(name) name PROC\n    #define KAI_ASM_FUNCTION_END(name) ENDP\n\n    #define KAI_ASM_CODE(name) AREA name, CODE, READONLY\n    #define KAI_ASM_ALIGN\n    #define KAI_ASM_LABEL(name) name\n    #define KAI_ASM_INST(hex) DCD hex\n    #define KAI_ASM_END END\n#else\n    #if defined(__APPLE__)\n        #define KAI_ASM_GLOBAL(name) .globl _##name\n        #define KAI_ASM_FUNCTION_TYPE(name)\n        #define KAI_ASM_FUNCTION_LABEL(name) _##name:\n        #define KAI_ASM_FUNCTION_END(name)\n    #else\n        #define KAI_ASM_GLOBAL(name) .global name\n        #define KAI_ASM_FUNCTION_TYPE(name) .type name, %function\n        #define KAI_ASM_FUNCTION_LABEL(name) name:\n        #define KAI_ASM_FUNCTION_END(name) .size name, .-name\n    #endif\n\n    #define KAI_ASM_CODE(name) .text\n    #define KAI_ASM_ALIGN .p2align 4,,11\n    #define KAI_ASM_LABEL(name) name:\n    #define KAI_ASM_INST(hex) .inst hex\n    #define KAI_ASM_END\n#endif\n\n    KAI_ASM_CODE(rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme)\n    KAI_ASM_ALIGN\n\n    KAI_ASM_GLOBAL(kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme)\n\nKAI_ASM_FUNCTION_TYPE(kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme)\nKAI_ASM_FUNCTION_LABEL(kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme)\n    stp x20, x21, [sp, -144]!\n    stp x22, x23, [sp, 16]\n    stp x24, x25, [sp, 32]\n    stp x26, x27, [sp, 48]\n    str x28, [sp, 64]\n    stp d8, d9, [sp, 72]\n    stp d10, d11, [sp, 88]\n    stp d12, d13, [sp, 104]\n    stp d14, d15, [sp, 120]\n    KAI_ASM_INST(0xd503477f)  // SMSTART ZA\n    ldr x14, [x0, #0x8]\n    ptrue p2.b\n    ldr x13, [x0, #0x38]\n    ldr x24, [x0, #0x0]\n    ldr x12, [x0, #0x10]\n    mov x23, x14\n    ldr x22, [x0, #0x18]\n    mov x21, x13\n    ldr x11, [x0, #0x20]\n    ldr x10, [x0, #0x28]\n    ldr x9, [x0, #0x30]\nKAI_ASM_LABEL(label_1)  // Bias: Full loop\n    mov x20, x23\n    decw x23, ALL, MUL #2\n    whilelt p1.s, XZR, x20\n    decw x20\n    whilelt p0.s, XZR, x20\n    cmp x23, #0x0\n    ld1w { z17.s }, p1/Z, [x24]\n    ld1w { z16.s }, p0/Z, [x24, #1, MUL VL]\n    incb x24, ALL, MUL #2\n    st1w { z17.s }, p2, [x21]\n    st1w { z16.s }, p2, [x21, #1, MUL VL]\n    add x21, x21, x10\n    bgt label_1\n    incb x13, ALL, MUL #2\n    mov x28, x22\nKAI_ASM_LABEL(label_2)  // Chunk Loop\n    mov x27, x12\n    cmp x27, #0x4\n    blt label_6\nKAI_ASM_LABEL(label_3)  // Main row loop: Head\n    mov x26, x9\n    mov x25, x13\n    add x24, x26, x11\n    sub x27, x27, #0x4\n    add x23, x24, x11\n    mov x22, x14\n    add x21, x23, x11\n    add x9, x21, x11\nKAI_ASM_LABEL(label_4)  // Main row loop: Column loop\n    mov x20, x22\n    decw x22, ALL, MUL #2\n    whilelt p1.s, XZR, x20\n    decw x20\n    whilelt p0.s, XZR, x20\n    cmp x22, #0x0\n    ld1w { z23.s }, p1/Z, [x26]\n    ld1w { z22.s }, p0/Z, [x26, #1, MUL VL]\n    addvl x26, x26, #2\n    ld1w { z21.s }, p1/Z, [x24]\n    ld1w { z20.s }, p0/Z, [x24, #1, MUL VL]\n    addvl x24, x24, #2\n    ld1w { z19.s }, p1/Z, [x23]\n    ld1w { z18.s }, p0/Z, [x23, #1, MUL VL]\n    addvl x23, x23, #2\n    ld1w { z17.s }, p1/Z, [x21]\n    ld1w { z16.s }, p0/Z, [x21, #1, MUL VL]\n    addvl x21, x21, #2\n    st1w { z23.s }, p2, [x25]\n    st1w { z22.s }, p2, [x25, #1, MUL VL]\n    st1w { z21.s }, p2, [x25, #2, MUL VL]\n    st1w { z20.s }, p2, [x25, #3, MUL VL]\n    st1w { z19.s }, p2, [x25, #4, MUL VL]\n    st1w { z18.s }, p2, [x25, #5, MUL VL]\n    st1w { z17.s }, p2, [x25, #6, MUL VL]\n    st1w { z16.s }, p2, [x25, #7, MUL VL]\n    add x25, x25, x10\n    bgt label_4\n    cmp x27, #0x4\n    addvl x13, x13, #8\n    bge label_3\n    cbz x27, label_10\nKAI_ASM_LABEL(label_6)  // Main loop skip\nKAI_ASM_LABEL(label_7)  // Tail row loop: Head\n    mov x26, x9\n    cntw x22, ALL, MUL #8\n    add x9, x26, x11\n    mov x25, x13\n    sub x27, x27, #0x1\n    mov x21, x14\nKAI_ASM_LABEL(label_8)  // Tail row loop: Column loop\n    mov x20, x21\n    decw x21, ALL, MUL #2\n    whilelt p1.s, XZR, x20\n    decw x20\n    whilelt p0.s, XZR, x20\n    cmp x21, #0x0\n    ld1w { z17.s }, p1/Z, [x26]\n    ld1w { z16.s }, p0/Z, [x26, #1, MUL VL]\n    add x26, x26, x22\n    st1w { z17.s }, p2, [x25]\n    st1w { z16.s }, p2, [x25, #1, MUL VL]\n    add x25, x25, x10\n    bgt label_8\n    cmp x27, #0x1\n    addvl x13, x13, #2\n    bge label_7\nKAI_ASM_LABEL(label_10)  // Done\n    sub x28, x28, #0x1\n    cbnz x28, label_2\n    KAI_ASM_INST(0xd503467f)  // SMSTOP\n    ldp x22, x23, [sp, 16]\n    ldp x24, x25, [sp, 32]\n    ldp x26, x27, [sp, 48]\n    ldr x28, [sp, 64]\n    ldp d8, d9, [sp, 72]\n    ldp d10, d11, [sp, 88]\n    ldp d12, d13, [sp, 104]\n    ldp d14, d15, [sp, 120]\n    ldp x20, x21, [sp], 144\n    ret\n    KAI_ASM_FUNCTION_END(kai_kernel_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme)\n\n    KAI_ASM_END\n"
+    },
     {
       "path": "kai_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla.h",
       "content": "//\n// SPDX-FileCopyrightText: Copyright 2024-2025 Arm Limited and/or its affiliates <open-source-office@arm.com>\n//\n// SPDX-License-Identifier: Apache-2.0\n//\n\n#pragma once\n\n#include <stddef.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif  // __cplusplus\n\n/// Micro-kernel dependencies\n///\n/// -# kai_rhs_pack_kxn_f32p16vlx1b_f32_f32_sme to pack the RHS matrix.\n\n/// --------------------------------------------------\n\n/// Gets m step value.\n///\n/// The starting row index must be divisible by `m_step`.\n///\n/// @return The m step value.\nsize_t kai_get_m_step_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(void);\n\n/// Gets n step value.\n///\n/// The starting column index must be divisible by `n_step`.\n///\n/// @return The n step value.\nsize_t kai_get_n_step_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(void);\n\n/// Gets nr value.\n///\n/// This is the packing parameter which must be used to pack the RHS matrix.\n///\n/// @return The nr value.\nsize_t kai_get_nr_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(void);\n\n/// Gets kr value.\n///\n/// This is the packing parameter which must be used to pack the RHS matrix.\n///\n/// @return The kr value.\nsize_t kai_get_kr_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(void);\n\n/// Gets sr value.\n///\n/// This is the packing parameter which must be used to pack the RHS matrix.\n///\n/// @return The sr value.\nsize_t kai_get_sr_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(void);\n\n/// Gets the offset in bytes to the data element in the LHS matrix buffer.\n///\n/// @param[in] m_idx Row index. This must be 0.\n/// @param[in] k     Columns of unpacked LHS.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_lhs_offset_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(size_t m_idx, size_t k);\n\n/// Gets the offset in bytes to the data element in the packed RHS matrix buffer.\n///\n/// @param[in] n_idx Column index in the unpacked RHS matrix. Must be a multiple of n_step\n/// @param[in] k Number of rows in the unpacked RHS matrix.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_rhs_packed_offset_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(size_t n_idx, size_t k);\n\n/// Gets the offset in bytes to the data element in the destination matrix buffer.\n///\n/// @param[in] m_idx Row index. Must be 0\n/// @param[in] n_idx Column index. Must be multiple of n_step\n/// @param[in] dst_stride Row stride in bytes.\n///\n/// @return The offset in bytes to the data element.\nsize_t kai_get_dst_offset_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(\n    size_t m_idx, size_t n_idx, size_t dst_stride);\n\n/// Gets the size in bytes of the destination matrix buffer.\n///\n/// @param[in] m Number of rows.\n/// @param[in] n Number of columns.\n///\n/// @return The size in bytes of the destination matrix buffer.\nsize_t kai_get_dst_size_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(size_t m, size_t n);\n\n/// Runs the matrix multiplication microkernel followed by a clamp operation.\n///\n/// The pointer of each buffers (LHS, packed RHS and output) needs to be added with offset\n/// calculated using the following functions:\n///\n///   * LHS: @ref kai_get_lhs_offset_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla.\n///   * Packed RHS: @ref kai_get_rhs_packed_offset_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla.\n///   * Output: @ref kai_get_dst_offset_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla.\n///\n/// @param[in]  m Number of output rows to be computed. This must be 1.\n/// @param[in]  n Number of output columns to be computed.\n/// @param[in]  k Common dimension of the LHS and RHS operand.\n/// @param[in]  lhs LHS matrix buffer.\n/// @param[in]  rhs_packed Packed RHS matrix buffer.\n/// @param[out] dst Output matrix buffer.\n/// @param[in]  dst_stride_row Row stride in bytes of the output matrix. Unused\n/// @param[in]  dst_stride_col Column stride in bytes of the output matrix. Unused\n/// @param[in]  clamp_min Minimum value to clamp the final result.\n/// @param[in]  clamp_max Maximum value to clamp the final result.\nvoid kai_run_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(\n    size_t m, size_t n, size_t k, const void* lhs, size_t lhs_stride, const void* rhs_packed, void* dst,\n    size_t dst_stride_row, size_t dst_stride_col, float clamp_min, float clamp_max);\n\n#ifdef __cplusplus\n}  // extern \"C\"\n#endif  // __cplusplus\n"
@@ -58,7 +94,7 @@
     },
     {
       "path": "binding.cpp",
-      "content": "// Binding for Arm KleidiAI's\n// kai_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla (pure SME2 GEMM,\n// full fp32, UNPACKED LHS) against gemm_fp32_sme2_n512_k512's raw ABI:\n//   armbench_entry_gemm(A*, output*, B*, bias*, M), C = A @ B + bias.\n//\n// Unlike every other kleidiai baseline in this dataset, this kernel's LHS\n// is NOT packed at all -- kai_run_matmul_..._sme2_mla takes raw A rows\n// directly (see kai_get_lhs_offset_..., \"no LHS-pack dependency listed in\n// the header). Only the RHS needs packing (kai_rhs_pack_kxn_f32p16vlx1b_\n// f32_f32_sme), which also bakes in the bias.\n//\n// This \"1x16vl\"-tile kernel variant hardcodes KAI_ASSUME(m == 1) --\n// confirmed in its own .c (same restriction shape as gemm_qs4c32_n256_\n// k512's SVE dotprod kernel, different underlying reason: here the whole\n// LHS is unpacked, so there's no packed-LHS-offset call needed, just plain\n// row pointer arithmetic on A directly).\n//\n// B arrives [K,N] row-major, matching kai_rhs_pack_kxn_...'s native \"kxn\"\n// input layout directly -- no transpose needed.\n#include <cstdint>\n#include <cstdlib>\n#include <cstring>\n#include <limits>\n\n#include \"kai/kai_common.h\"\n#include \"kai_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla.h\"\n#include \"kai_rhs_pack_kxn_f32p16vlx1b_f32_f32_sme.h\"\n\nnamespace {\nconstexpr int N = 512;\nconstexpr int K = 512;\n\n// True if `data` (size bytes) differs from the cached snapshot, and updates\n// the snapshot to match when it does. Content-based, not pointer-based:\n// bench.cli evaluates many workloads against one compiled .so, and a later,\n// genuinely different workload's input buffer can land at the exact address\n// an earlier (now-freed) workload's buffer used -- a pointer-identity cache\n// would then wrongly treat different data as unchanged and reuse a stale\n// pack. See github.com/ArtificialRay/CPU-Kernel-Baseline/issues/80.\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n    const bool stale =\n        snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n    if (stale) {\n        if (snapshot_size != size) {\n            std::free(snapshot);\n            snapshot = static_cast<uint8_t*>(std::malloc(size));\n            snapshot_size = size;\n        }\n        std::memcpy(snapshot, data, size);\n    }\n    return stale;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, const float* bias, int M)\n{\n    const size_t nr = kai_get_nr_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla();\n    const size_t kr = kai_get_kr_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla();\n    const size_t sr = kai_get_sr_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla();\n\n    // --- RHS: pack B [K, N] f32 (+ bias), cached across calls whose B AND\n    // bias content match the last pack.\n    static uint8_t* B_snapshot = nullptr;\n    static size_t B_snapshot_size = 0;\n    static uint8_t* bias_snapshot = nullptr;\n    static size_t bias_snapshot_size = 0;\n    static void* rhs_packed = nullptr;\n    const size_t B_bytes = sizeof(float) * (size_t)N * (size_t)K;\n    const size_t bias_bytes = sizeof(float) * (size_t)N;\n    const bool B_stale = refresh_cache(B_snapshot, B_snapshot_size, B, B_bytes);\n    const bool bias_stale = refresh_cache(bias_snapshot, bias_snapshot_size, bias, bias_bytes);\n    if (B_stale || bias_stale) {\n        std::free(rhs_packed);\n        const size_t rhs_packed_size =\n            kai_get_rhs_packed_size_rhs_pack_kxn_f32p16vlx1b_f32_f32_sme((size_t)N, (size_t)K);\n        rhs_packed = std::malloc(rhs_packed_size);\n        if (rhs_packed == nullptr) return -1;\n\n        kai_run_rhs_pack_kxn_f32p16vlx1b_f32_f32_sme(\n            /*num_groups=*/1, (size_t)N, (size_t)K, nr, kr, sr,\n            /*rhs_stride_row=*/(size_t)N * sizeof(float), B, bias, /*scale=*/nullptr,\n            rhs_packed, /*extra_bytes=*/0, /*params=*/nullptr);\n    }\n\n    // --- matmul + clamp: LHS is unpacked, loop one row at a time (m == 1) ---\n    for (int m_idx = 0; m_idx < M; ++m_idx) {\n        const float* lhs_row = A + (size_t)m_idx * (size_t)K;\n        // kai_get_dst_offset_...'s m_idx param must be 0 (KAI_ASSERT) -- it is\n        // NOT a per-row offset calculator; compute the row offset ourselves.\n        float* dst_row = output + (size_t)m_idx * (size_t)N;\n\n        kai_run_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(\n            /*m=*/1, (size_t)N, (size_t)K,\n            lhs_row, /*lhs_stride=*/(size_t)K * sizeof(float), rhs_packed,\n            dst_row,\n            /*dst_stride_row=*/(size_t)N * sizeof(float), /*dst_stride_col=*/sizeof(float),\n            -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());\n    }\n\n    return 0;\n}\n"
+      "content": "// Binding for Arm KleidiAI's fp32 SME2 GEMM against gemm_fp32_sme2_n512_k512's\n// raw ABI: armbench_entry_gemm(A*, output*, B*, bias*, M), C = A @ B + bias.\n//\n// DISPATCHES between two real kernels by M -- see gemm_f16_n512_k512's\n// binding.cpp for the full rationale (same kernel family, same\n// mr(2)*512-bit-SVL/kr math gives m_step=32 for the mopa kernel here too):\n//   M <  DISPATCH_THRESHOLD (8): kai_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla\n//     -- a GEMV kernel (m_step=1, UNPACKED LHS), looped once per row.\n//   M >= DISPATCH_THRESHOLD: kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa\n//     -- a genuine multi-row SME2 mopa kernel, called ONCE for the whole M\n//     via a trivial k_chunk_count=1 indirection table.\n//\n// Measured on Apple M4: GEMV wins at M=1 and M=4 (0.67x/1.39x of the mopa\n// kernel's time -- M=1 was noisy across separate runs, but M=4 was\n// consistently slower with mopa), and mopa is at least even by M=8\n// (~1.0x) with a clear, growing lead from there. 8 is picked as the first\n// point the crossover was observed to have already happened.\n//\n// dst is native f32 for both kernels here (unlike gemm_f16's f16 output),\n// so no scratch/conversion buffer is needed in either path.\n//\n// RHS packing is a DIFFERENT function/format for each kernel\n// (kai_rhs_pack_kxn_f32p16vlx1b_f32_f32_sme for the GEMV path vs.\n// kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme for the mopa path) -- so\n// each path keeps its OWN independent weight-content cache; only the path\n// actually taken for a given call touches its cache.\n#include <cstdint>\n#include <cstdlib>\n#include <cstring>\n#include <limits>\n\n#include \"kai/kai_common.h\"\n#include \"kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa.h\"\n#include \"kai_lhs_imatmul_pack_x32p2vlx1_x32p_sme.h\"\n#include \"kai_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla.h\"\n#include \"kai_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme.h\"\n#include \"kai_rhs_pack_kxn_f32p16vlx1b_f32_f32_sme.h\"\n\nnamespace {\nconstexpr int N = 512;\nconstexpr int K = 512;\nconstexpr int DISPATCH_THRESHOLD = 8;  // M < this -> GEMV kernel, else -> GEMM kernel. See file header.\n\n// True if `data` (size bytes) differs from the cached snapshot, and updates\n// the snapshot to match when it does. Content-based, not pointer-based --\n// see conv2d_depthwise_fp32_nhwc_kh3_kw3_s1_p1's binding.cpp for why\n// (github.com/ArtificialRay/CPU-Kernel-Baseline/issues/80).\nbool refresh_cache(uint8_t*& snapshot, size_t& snapshot_size, const void* data, size_t size) {\n    const bool stale =\n        snapshot == nullptr || snapshot_size != size || std::memcmp(snapshot, data, size) != 0;\n    if (stale) {\n        if (snapshot_size != size) {\n            std::free(snapshot);\n            snapshot = static_cast<uint8_t*>(std::malloc(size));\n            snapshot_size = size;\n        }\n        std::memcpy(snapshot, data, size);\n    }\n    return stale;\n}\n\n// --- GEMV path (M < DISPATCH_THRESHOLD): kai_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla,\n// unpacked LHS, one row per call. Own weight cache (own RHS pack format). ---\nint run_gemv(const float* A, float* output, const float* B, const float* bias, int M)\n{\n    const size_t nr = kai_get_nr_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla();\n    const size_t kr = kai_get_kr_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla();\n    const size_t sr = kai_get_sr_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla();\n\n    static uint8_t* B_snapshot = nullptr;\n    static size_t B_snapshot_size = 0;\n    static uint8_t* bias_snapshot = nullptr;\n    static size_t bias_snapshot_size = 0;\n    static void* rhs_packed = nullptr;\n    const size_t B_bytes = sizeof(float) * (size_t)N * (size_t)K;\n    const size_t bias_bytes = sizeof(float) * (size_t)N;\n    const bool B_stale = refresh_cache(B_snapshot, B_snapshot_size, B, B_bytes);\n    const bool bias_stale = refresh_cache(bias_snapshot, bias_snapshot_size, bias, bias_bytes);\n    if (B_stale || bias_stale) {\n        std::free(rhs_packed);\n        const size_t rhs_packed_size =\n            kai_get_rhs_packed_size_rhs_pack_kxn_f32p16vlx1b_f32_f32_sme((size_t)N, (size_t)K);\n        rhs_packed = std::malloc(rhs_packed_size);\n        if (rhs_packed == nullptr) return -1;\n\n        kai_run_rhs_pack_kxn_f32p16vlx1b_f32_f32_sme(\n            /*num_groups=*/1, (size_t)N, (size_t)K, nr, kr, sr,\n            /*rhs_stride_row=*/(size_t)N * sizeof(float), B, bias, /*scale=*/nullptr,\n            rhs_packed, /*extra_bytes=*/0, /*params=*/nullptr);\n    }\n\n    for (int m_idx = 0; m_idx < M; ++m_idx) {\n        const float* lhs_row = A + (size_t)m_idx * (size_t)K;\n        float* dst_row = output + (size_t)m_idx * (size_t)N;\n\n        kai_run_matmul_clamp_f32_f32_f32p16vlx1b_1x16vl_sme2_mla(\n            /*m=*/1, (size_t)N, (size_t)K,\n            lhs_row, /*lhs_stride=*/(size_t)K * sizeof(float), rhs_packed,\n            dst_row,\n            /*dst_stride_row=*/(size_t)N * sizeof(float), /*dst_stride_col=*/sizeof(float),\n            -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());\n    }\n    return 0;\n}\n\n// --- GEMM path (M >= DISPATCH_THRESHOLD): kai_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa,\n// called once for the whole M via a trivial k_chunk_count=1 indirection.\n// Own weight cache (own RHS pack format). ---\nint run_gemm(const float* A, float* output, const float* B, const float* bias, int M)\n{\n    const size_t k_chunk_count = 1;\n    const size_t k_chunk_length = (size_t)K;\n    const size_t m_step = kai_get_m_step_lhs_imatmul_pack_x32p2vlx1_x32p_sme();\n    const size_t num_blocks = ((size_t)M + m_step - 1) / m_step;\n\n    static float* pad_chunk = nullptr;\n    if (pad_chunk == nullptr) {\n        pad_chunk = static_cast<float*>(std::calloc((size_t)K, sizeof(float)));\n        if (pad_chunk == nullptr) return -1;\n    }\n\n    static const float* cached_A = nullptr;\n    static int cached_M = -1;\n    static const void** indirection = nullptr;\n    static void* lhs_packed = nullptr;\n    static size_t lhs_cap = 0;\n    if (A != cached_A || M != cached_M) {\n        std::free(indirection);\n        const size_t total_slots = num_blocks * m_step * k_chunk_count;\n        indirection = static_cast<const void**>(std::malloc(sizeof(void*) * total_slots));\n        if (indirection == nullptr) { cached_A = nullptr; return -1; }\n\n        for (size_t block = 0; block < num_blocks; ++block) {\n            const size_t m_block_start = block * m_step;\n            for (size_t row = 0; row < m_step; ++row) {\n                const size_t dst_idx = block * m_step + row;\n                const size_t m_idx = m_block_start + row;\n                indirection[dst_idx] = (m_idx < (size_t)M) ? (const void*)(A + m_idx * (size_t)K) : pad_chunk;\n            }\n        }\n        cached_A = A;\n        cached_M = M;\n    }\n    {\n        const size_t lhs_packed_size =\n            kai_get_lhs_packed_size_lhs_imatmul_pack_x32p2vlx1_x32p_sme((size_t)M, k_chunk_count, k_chunk_length);\n        if (lhs_packed_size > lhs_cap) {\n            std::free(lhs_packed);\n            lhs_packed = std::malloc(lhs_packed_size);\n            lhs_cap = lhs_packed_size;\n            if (lhs_packed == nullptr) return -1;\n        }\n        kai_run_lhs_imatmul_pack_x32p2vlx1_x32p_sme(\n            (size_t)M, k_chunk_count, k_chunk_length, indirection, /*lhs_ptr_offset=*/0, pad_chunk, lhs_packed);\n    }\n\n    static uint8_t* B_snapshot = nullptr;\n    static size_t B_snapshot_size = 0;\n    static uint8_t* bias_snapshot = nullptr;\n    static size_t bias_snapshot_size = 0;\n    static void* rhs_packed = nullptr;\n    const size_t B_bytes = sizeof(float) * (size_t)N * (size_t)K;\n    const size_t bias_bytes = sizeof(float) * (size_t)N;\n    const bool B_stale = refresh_cache(B_snapshot, B_snapshot_size, B, B_bytes);\n    const bool bias_stale = refresh_cache(bias_snapshot, bias_snapshot_size, bias, bias_bytes);\n    if (B_stale || bias_stale) {\n        std::free(rhs_packed);\n        const size_t rhs_packed_size = kai_get_rhs_packed_size_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n            (size_t)N, k_chunk_count, k_chunk_length);\n        rhs_packed = std::malloc(rhs_packed_size);\n        if (rhs_packed == nullptr) return -1;\n\n        kai_run_rhs_imatmul_pack_kxn_x32p2vlx1b_x32_x32_sme(\n            (size_t)N, k_chunk_count, k_chunk_length,\n            /*rhs_stride_row=*/(size_t)N * sizeof(float), B, bias, rhs_packed);\n    }\n\n    kai_run_imatmul_clamp_f32_f32p2vlx1_f32p2vlx1b_2vlx2vl_sme2_mopa(\n        (size_t)M, (size_t)N, k_chunk_count, k_chunk_length, lhs_packed, rhs_packed,\n        output, /*dst_stride_row=*/(size_t)N * sizeof(float),\n        -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());\n    return 0;\n}\n} // namespace\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, const float* bias, int M)\n{\n    return (M < DISPATCH_THRESHOLD) ? run_gemv(A, output, B, bias, M) : run_gemm(A, output, B, bias, M);\n}\n"
     }
   ]
 }

solutions/ncnn/baseline-ncnn-arm/gemm/gemm_fp32_n1000_k1280.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_gemm_fp32_n1000_k1280",
-  "definition": "gemm_fp32_n1000_k1280",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "baseline-ncnn-arm baseline for gemm_fp32_n1000_k1280. binding.cpp bakes constexpr params and implements armbench_entry_gemm with a void* ABI; kernel.cpp delegates to the backend library. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "gemm_contract.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for gemm baseline (C = A @ B^T).\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is a genuine 2D Mat (w=K, h=M); B is flat 1D (N*K, ncnn InnerProduct\n// weight_data layout); top is pre-allocated 2D (w=N, h=M) by binding.cpp.\nnamespace ncnn {\nint gemm_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm_contract.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int N = 1000;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_gemm(\n    void* A_v, void* top_v,\n    void* B_v, void* opt_v)\n{\n    const auto& A   = *reinterpret_cast<const ncnn::Mat*>(A_v);\n    auto&       top = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& B   = *reinterpret_cast<const ncnn::Mat*>(B_v);\n    const auto& opt = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // A arrives as a genuine 2D Mat (w=K, h=M) \u2014 M (rows) varies per workload.\n    const int M = A.h;\n\n    top.create(N, M, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::gemm_kernel(A, top, B, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm_contract.h\"\n#include \"innerproduct_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nnamespace {\nconstexpr int N = 1000;\nconstexpr int K = 1280;\n} // namespace\n\nint ncnn::gemm_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data,\n    const Option& opt)\n{\n    InnerProduct_arm ip;\n    ip.num_output       = N;\n    ip.bias_term        = 0;\n    ip.weight_data_size = N * K;\n    ip.int8_scale_term  = 0;\n    ip.activation_type  = 0;\n    ip.activation_params = Mat();\n    // weight_data is flat (N*K), row-major with K contiguous \u2014 exactly the\n    // layout InnerProduct_arm expects (reshape(K, N) done in create_pipeline).\n    ip.weight_data      = const_cast<Mat&>(weight_data);\n\n    if (ip.create_pipeline(opt) != 0) return -1;\n\n    // bottom_blob is a genuine 2D Mat (w=K, h=M) \u2014 InnerProduct_arm handles the\n    // full (M,K)->(M,N) gemm in one forward() call when dims==2.\n    Mat local_top;\n    if (ip.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    const int M = top_blob.h;\n    for (int m = 0; m < M; ++m)\n        std::memcpy(top_blob.row(m), local_top.row(m), N * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/gemm/gemm_fp32_n1000_k2048.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_gemm_fp32_n1000_k2048",
-  "definition": "gemm_fp32_n1000_k2048",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "baseline-ncnn-arm baseline for gemm_fp32_n1000_k2048. binding.cpp bakes constexpr params and implements armbench_entry_gemm with a void* ABI; kernel.cpp delegates to the backend library. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "gemm_contract.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for gemm baseline (C = A @ B^T).\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is a genuine 2D Mat (w=K, h=M); B is flat 1D (N*K, ncnn InnerProduct\n// weight_data layout); top is pre-allocated 2D (w=N, h=M) by binding.cpp.\nnamespace ncnn {\nint gemm_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm_contract.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int N = 1000;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_gemm(\n    void* A_v, void* top_v,\n    void* B_v, void* opt_v)\n{\n    const auto& A   = *reinterpret_cast<const ncnn::Mat*>(A_v);\n    auto&       top = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& B   = *reinterpret_cast<const ncnn::Mat*>(B_v);\n    const auto& opt = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // A arrives as a genuine 2D Mat (w=K, h=M) \u2014 M (rows) varies per workload.\n    const int M = A.h;\n\n    top.create(N, M, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::gemm_kernel(A, top, B, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm_contract.h\"\n#include \"innerproduct_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nnamespace {\nconstexpr int N = 1000;\nconstexpr int K = 2048;\n} // namespace\n\nint ncnn::gemm_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data,\n    const Option& opt)\n{\n    InnerProduct_arm ip;\n    ip.num_output       = N;\n    ip.bias_term        = 0;\n    ip.weight_data_size = N * K;\n    ip.int8_scale_term  = 0;\n    ip.activation_type  = 0;\n    ip.activation_params = Mat();\n    // weight_data is flat (N*K), row-major with K contiguous \u2014 exactly the\n    // layout InnerProduct_arm expects (reshape(K, N) done in create_pipeline).\n    ip.weight_data      = const_cast<Mat&>(weight_data);\n\n    if (ip.create_pipeline(opt) != 0) return -1;\n\n    // bottom_blob is a genuine 2D Mat (w=K, h=M) \u2014 InnerProduct_arm handles the\n    // full (M,K)->(M,N) gemm in one forward() call when dims==2.\n    Mat local_top;\n    if (ip.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    const int M = top_blob.h;\n    for (int m = 0; m < M; ++m)\n        std::memcpy(top_blob.row(m), local_top.row(m), N * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/gemm/gemm_fp32_n1280_k960.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_gemm_fp32_n1280_k960",
-  "definition": "gemm_fp32_n1280_k960",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "baseline-ncnn-arm baseline for gemm_fp32_n1280_k960. binding.cpp bakes constexpr params and implements armbench_entry_gemm with a void* ABI; kernel.cpp delegates to the backend library. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "gemm_contract.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for gemm baseline (C = A @ B^T).\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is a genuine 2D Mat (w=K, h=M); B is flat 1D (N*K, ncnn InnerProduct\n// weight_data layout); top is pre-allocated 2D (w=N, h=M) by binding.cpp.\nnamespace ncnn {\nint gemm_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm_contract.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int N = 1280;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_gemm(\n    void* A_v, void* top_v,\n    void* B_v, void* opt_v)\n{\n    const auto& A   = *reinterpret_cast<const ncnn::Mat*>(A_v);\n    auto&       top = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& B   = *reinterpret_cast<const ncnn::Mat*>(B_v);\n    const auto& opt = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // A arrives as a genuine 2D Mat (w=K, h=M) \u2014 M (rows) varies per workload.\n    const int M = A.h;\n\n    top.create(N, M, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::gemm_kernel(A, top, B, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm_contract.h\"\n#include \"innerproduct_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nnamespace {\nconstexpr int N = 1280;\nconstexpr int K = 960;\n} // namespace\n\nint ncnn::gemm_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data,\n    const Option& opt)\n{\n    InnerProduct_arm ip;\n    ip.num_output       = N;\n    ip.bias_term        = 0;\n    ip.weight_data_size = N * K;\n    ip.int8_scale_term  = 0;\n    ip.activation_type  = 0;\n    ip.activation_params = Mat();\n    // weight_data is flat (N*K), row-major with K contiguous \u2014 exactly the\n    // layout InnerProduct_arm expects (reshape(K, N) done in create_pipeline).\n    ip.weight_data      = const_cast<Mat&>(weight_data);\n\n    if (ip.create_pipeline(opt) != 0) return -1;\n\n    // bottom_blob is a genuine 2D Mat (w=K, h=M) \u2014 InnerProduct_arm handles the\n    // full (M,K)->(M,N) gemm in one forward() call when dims==2.\n    Mat local_top;\n    if (ip.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    const int M = top_blob.h;\n    for (int m = 0; m < M; ++m)\n        std::memcpy(top_blob.row(m), local_top.row(m), N * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/gemm/gemm_fp32_n29_k800.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_gemm_fp32_n29_k800",
-  "definition": "gemm_fp32_n29_k800",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "baseline-ncnn-arm baseline for gemm_fp32_n29_k800. binding.cpp bakes constexpr params and implements armbench_entry_gemm with a void* ABI; kernel.cpp delegates to the backend library. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "gemm_contract.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for gemm baseline (C = A @ B^T).\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is a genuine 2D Mat (w=K, h=M); B is flat 1D (N*K, ncnn InnerProduct\n// weight_data layout); top is pre-allocated 2D (w=N, h=M) by binding.cpp.\nnamespace ncnn {\nint gemm_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm_contract.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int N = 29;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_gemm(\n    void* A_v, void* top_v,\n    void* B_v, void* opt_v)\n{\n    const auto& A   = *reinterpret_cast<const ncnn::Mat*>(A_v);\n    auto&       top = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& B   = *reinterpret_cast<const ncnn::Mat*>(B_v);\n    const auto& opt = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // A arrives as a genuine 2D Mat (w=K, h=M) \u2014 M (rows) varies per workload.\n    const int M = A.h;\n\n    top.create(N, M, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::gemm_kernel(A, top, B, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm_contract.h\"\n#include \"innerproduct_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n\nnamespace {\nconstexpr int N = 29;\nconstexpr int K = 800;\n} // namespace\n\nint ncnn::gemm_kernel(\n    const Mat& bottom_blob, Mat& top_blob,\n    const Mat& weight_data,\n    const Option& opt)\n{\n    InnerProduct_arm ip;\n    ip.num_output       = N;\n    ip.bias_term        = 0;\n    ip.weight_data_size = N * K;\n    ip.int8_scale_term  = 0;\n    ip.activation_type  = 0;\n    ip.activation_params = Mat();\n    // weight_data is flat (N*K), row-major with K contiguous \u2014 exactly the\n    // layout InnerProduct_arm expects (reshape(K, N) done in create_pipeline).\n    ip.weight_data      = const_cast<Mat&>(weight_data);\n\n    if (ip.create_pipeline(opt) != 0) return -1;\n\n    // bottom_blob is a genuine 2D Mat (w=K, h=M) \u2014 InnerProduct_arm handles the\n    // full (M,K)->(M,N) gemm in one forward() call when dims==2.\n    Mat local_top;\n    if (ip.forward(bottom_blob, local_top, opt) != 0) return -1;\n\n    const int M = top_blob.h;\n    for (int m = 0; m < M; ++m)\n        std::memcpy(top_blob.row(m), local_top.row(m), N * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/gemm/gemm_w8a8ch_n1000_k1280.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_gemm_w8a8ch_n1000_k1280",
-  "definition": "gemm_w8a8ch_n1000_k1280",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "baseline-ncnn-arm baseline for gemm_w8a8ch_n1000_k1280. binding.cpp bakes constexpr params and implements armbench_entry_gemm with a void* ABI; kernel.cpp delegates to the backend library. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "gemm_w8a8ch_contract.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for gemm w8a8ch (int8) baseline (C = A @ B^T, no bias).\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is a genuine 2D int8 Mat (w=K, h=M); B is flat int8 (N*K). top is\n// pre-allocated 2D int8 (w=N, h=M) by binding.cpp \u2014 InnerProduct_arm's int8\n// path never produces int8 output itself (only dequantizes to float32), so\n// kernel.cpp does the final round+clip+cast to int8 by hand.\nnamespace ncnn {\nint gemm_w8a8ch_kernel(\n    const Mat& A, Mat& top,\n    const Mat& B, const Mat& weight_scales,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm_w8a8ch_contract.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int N = 1000;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_gemm(\n    void* A_v, void* top_v,\n    void* B_v, void* weight_scales_v,\n    void* opt_v)\n{\n    const auto& A             = *reinterpret_cast<const ncnn::Mat*>(A_v);\n    auto&       top           = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& B             = *reinterpret_cast<const ncnn::Mat*>(B_v);\n    const auto& weight_scales = *reinterpret_cast<const ncnn::Mat*>(weight_scales_v);\n    const auto& opt           = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // A arrives as a genuine 2D Mat (w=K, h=M) \u2014 M (rows) varies per workload.\n    const int M = A.h;\n\n    // Dequantized float32 output \u2014 same elemsize as the fp32 baseline. w8a8ch\n    // only quantizes inputs; the task doesn't require requantizing the result.\n    top.create(N, M, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::gemm_w8a8ch_kernel(A, top, B, weight_scales, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm_w8a8ch_contract.h\"\n#include \"innerproduct_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n#include <cstdint>\n\nnamespace {\nconstexpr int N = 1000;\nconstexpr int K = 1280;\nconstexpr float input_scale = 0.01;\n\n// create_pipeline (int8 weight quantize/repack) is expensive and depends only\n// on the weights, which are constant across bench's 56 reps per workload but\n// CHANGE between workloads (bench reuses the input buffers, so pointers are\n// stable \u2014 can't key on them). Hoist create_pipeline into a cache keyed on a\n// cheap content hash of weight_scales (4KB, changes per workload) so it runs\n// once per workload (in the untimed warmup) and the 50 timed reps run only\n// forward(); otherwise the repack dominates timing and the \"expert\" baseline\n// looks ~14x slower than it is.\ninline uint64_t fnv1a(const void* p, size_t n) {\n    const unsigned char* b = (const unsigned char*)p;\n    uint64_t h = 1469598103934665603ULL;\n    for (size_t i = 0; i < n; ++i) { h ^= b[i]; h *= 1099511628211ULL; }\n    return h;\n}\nstruct Cache {\n    ncnn::InnerProduct_arm ip;\n    ncnn::Mat wscale, bscale;\n    ncnn::Option opt;\n    uint64_t key = 0;\n    bool built = false;\n};\nCache g;\n} // namespace\n\nint ncnn::gemm_w8a8ch_kernel(\n    const Mat& A, Mat& top,\n    const Mat& B, const Mat& weight_scales,\n    const Option& opt)\n{\n    const uint64_t key = fnv1a(weight_scales.data, (size_t)N * sizeof(float));\n    if (!g.built || g.key != key) {\n        if (g.built) { g.ip.destroy_pipeline(g.opt); g.built = false; }\n        // ncnn int8 scale fields are *quantization* multipliers; this baseline's\n        // scales are *dequantization* multipliers \u2014 invert them.\n        g.wscale.create(N, (size_t)4u);\n        if (g.wscale.empty()) return -1;\n        const float* ws = (const float*)weight_scales.data;\n        for (int p = 0; p < N; ++p) g.wscale[p] = 1.0f / ws[p];\n        g.bscale.create(1, (size_t)4u);\n        if (g.bscale.empty()) return -1;\n        g.bscale[0] = 1.0f / input_scale;\n        g.ip.num_output          = N;\n        g.ip.bias_term           = 0;\n        g.ip.weight_data_size    = N * K;\n        g.ip.int8_scale_term     = 1;\n        g.ip.activation_type     = 0;\n        g.ip.activation_params   = Mat();\n        g.ip.weight_data             = const_cast<Mat&>(B);\n        g.ip.weight_data_int8_scales = g.wscale;\n        g.ip.bottom_blob_int8_scales = g.bscale;\n        if (g.ip.create_pipeline(opt) != 0) return -1;\n        g.opt = opt; g.key = key; g.built = true;\n    }\n\n    Mat local_top_fp32;\n    if (g.ip.forward(A, local_top_fp32, opt) != 0) return -1;\n    const int M = top.h;\n    for (int m = 0; m < M; ++m)\n        std::memcpy((float*)top.row(m), local_top_fp32.row(m), N * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/gemm/gemm_w8a8ch_n1000_k2048.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_gemm_w8a8ch_n1000_k2048",
-  "definition": "gemm_w8a8ch_n1000_k2048",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "baseline-ncnn-arm baseline for gemm_w8a8ch_n1000_k2048. binding.cpp bakes constexpr params and implements armbench_entry_gemm with a void* ABI; kernel.cpp delegates to the backend library. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "gemm_w8a8ch_contract.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for gemm w8a8ch (int8) baseline (C = A @ B^T, no bias).\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is a genuine 2D int8 Mat (w=K, h=M); B is flat int8 (N*K). top is\n// pre-allocated 2D int8 (w=N, h=M) by binding.cpp \u2014 InnerProduct_arm's int8\n// path never produces int8 output itself (only dequantizes to float32), so\n// kernel.cpp does the final round+clip+cast to int8 by hand.\nnamespace ncnn {\nint gemm_w8a8ch_kernel(\n    const Mat& A, Mat& top,\n    const Mat& B, const Mat& weight_scales,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm_w8a8ch_contract.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int N = 1000;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_gemm(\n    void* A_v, void* top_v,\n    void* B_v, void* weight_scales_v,\n    void* opt_v)\n{\n    const auto& A             = *reinterpret_cast<const ncnn::Mat*>(A_v);\n    auto&       top           = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& B             = *reinterpret_cast<const ncnn::Mat*>(B_v);\n    const auto& weight_scales = *reinterpret_cast<const ncnn::Mat*>(weight_scales_v);\n    const auto& opt           = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // A arrives as a genuine 2D Mat (w=K, h=M) \u2014 M (rows) varies per workload.\n    const int M = A.h;\n\n    // Dequantized float32 output \u2014 same elemsize as the fp32 baseline. w8a8ch\n    // only quantizes inputs; the task doesn't require requantizing the result.\n    top.create(N, M, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::gemm_w8a8ch_kernel(A, top, B, weight_scales, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm_w8a8ch_contract.h\"\n#include \"innerproduct_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n#include <cstdint>\n\nnamespace {\nconstexpr int N = 1000;\nconstexpr int K = 2048;\nconstexpr float input_scale = 0.01;\n\n// create_pipeline (int8 weight quantize/repack) is expensive and depends only\n// on the weights, which are constant across bench's 56 reps per workload but\n// CHANGE between workloads (bench reuses the input buffers, so pointers are\n// stable \u2014 can't key on them). Hoist create_pipeline into a cache keyed on a\n// cheap content hash of weight_scales (4KB, changes per workload) so it runs\n// once per workload (in the untimed warmup) and the 50 timed reps run only\n// forward(); otherwise the repack dominates timing and the \"expert\" baseline\n// looks ~14x slower than it is.\ninline uint64_t fnv1a(const void* p, size_t n) {\n    const unsigned char* b = (const unsigned char*)p;\n    uint64_t h = 1469598103934665603ULL;\n    for (size_t i = 0; i < n; ++i) { h ^= b[i]; h *= 1099511628211ULL; }\n    return h;\n}\nstruct Cache {\n    ncnn::InnerProduct_arm ip;\n    ncnn::Mat wscale, bscale;\n    ncnn::Option opt;\n    uint64_t key = 0;\n    bool built = false;\n};\nCache g;\n} // namespace\n\nint ncnn::gemm_w8a8ch_kernel(\n    const Mat& A, Mat& top,\n    const Mat& B, const Mat& weight_scales,\n    const Option& opt)\n{\n    const uint64_t key = fnv1a(weight_scales.data, (size_t)N * sizeof(float));\n    if (!g.built || g.key != key) {\n        if (g.built) { g.ip.destroy_pipeline(g.opt); g.built = false; }\n        // ncnn int8 scale fields are *quantization* multipliers; this baseline's\n        // scales are *dequantization* multipliers \u2014 invert them.\n        g.wscale.create(N, (size_t)4u);\n        if (g.wscale.empty()) return -1;\n        const float* ws = (const float*)weight_scales.data;\n        for (int p = 0; p < N; ++p) g.wscale[p] = 1.0f / ws[p];\n        g.bscale.create(1, (size_t)4u);\n        if (g.bscale.empty()) return -1;\n        g.bscale[0] = 1.0f / input_scale;\n        g.ip.num_output          = N;\n        g.ip.bias_term           = 0;\n        g.ip.weight_data_size    = N * K;\n        g.ip.int8_scale_term     = 1;\n        g.ip.activation_type     = 0;\n        g.ip.activation_params   = Mat();\n        g.ip.weight_data             = const_cast<Mat&>(B);\n        g.ip.weight_data_int8_scales = g.wscale;\n        g.ip.bottom_blob_int8_scales = g.bscale;\n        if (g.ip.create_pipeline(opt) != 0) return -1;\n        g.opt = opt; g.key = key; g.built = true;\n    }\n\n    Mat local_top_fp32;\n    if (g.ip.forward(A, local_top_fp32, opt) != 0) return -1;\n    const int M = top.h;\n    for (int m = 0; m < M; ++m)\n        std::memcpy((float*)top.row(m), local_top_fp32.row(m), N * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/baseline-ncnn-arm/gemm/gemm_w8a8ch_n1280_k960.json

@@ -1,40 +0,0 @@
-{
-  "name": "baseline-ncnn-arm_gemm_w8a8ch_n1280_k960",
-  "definition": "gemm_w8a8ch_n1280_k960",
-  "dataset": "ncnn",
-  "author": "baseline-ncnn-arm",
-  "description": "baseline-ncnn-arm baseline for gemm_w8a8ch_n1280_k960. binding.cpp bakes constexpr params and implements armbench_entry_gemm with a void* ABI; kernel.cpp delegates to the backend library. Timing baseline for speedup computation.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve",
-      "graviton4",
-      "aarch64-sve2"
-    ],
-    "entry_point": "binding.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O3",
-      "-std=c++17"
-    ],
-    "link_flags": [
-      "-fopenmp"
-    ]
-  },
-  "sources": [
-    {
-      "path": "gemm_w8a8ch_contract.h",
-      "content": "#pragma once\n#include \"mat.h\"\n#include \"option.h\"\n\n// Harness contract for gemm w8a8ch (int8) baseline (C = A @ B^T, no bias).\n// Called by armbench_entry_gemm (binding.cpp); implemented by kernel.cpp.\n// A is a genuine 2D int8 Mat (w=K, h=M); B is flat int8 (N*K). top is\n// pre-allocated 2D int8 (w=N, h=M) by binding.cpp \u2014 InnerProduct_arm's int8\n// path never produces int8 output itself (only dequantizes to float32), so\n// kernel.cpp does the final round+clip+cast to int8 by hand.\nnamespace ncnn {\nint gemm_w8a8ch_kernel(\n    const Mat& A, Mat& top,\n    const Mat& B, const Mat& weight_scales,\n    const Option& opt);\n}\n"
-    },
-    {
-      "path": "binding.cpp",
-      "content": "#include \"gemm_w8a8ch_contract.h\"\n#include \"mat.h\"\n#include \"option.h\"\n\nnamespace {\nconstexpr int N = 1280;\n} // namespace\n\nextern \"C\" {\nint armbench_entry_gemm(\n    void* A_v, void* top_v,\n    void* B_v, void* weight_scales_v,\n    void* opt_v)\n{\n    const auto& A             = *reinterpret_cast<const ncnn::Mat*>(A_v);\n    auto&       top           = *reinterpret_cast<ncnn::Mat*>(top_v);\n    const auto& B             = *reinterpret_cast<const ncnn::Mat*>(B_v);\n    const auto& weight_scales = *reinterpret_cast<const ncnn::Mat*>(weight_scales_v);\n    const auto& opt           = *reinterpret_cast<const ncnn::Option*>(opt_v);\n\n    // A arrives as a genuine 2D Mat (w=K, h=M) \u2014 M (rows) varies per workload.\n    const int M = A.h;\n\n    // Dequantized float32 output \u2014 same elemsize as the fp32 baseline. w8a8ch\n    // only quantizes inputs; the task doesn't require requantizing the result.\n    top.create(N, M, (size_t)4u, opt.blob_allocator);\n    if (top.empty()) return -1;\n\n    return ncnn::gemm_w8a8ch_kernel(A, top, B, weight_scales, opt);\n}\n} // extern \"C\"\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm_w8a8ch_contract.h\"\n#include \"innerproduct_arm.h\"\n#include \"mat.h\"\n#include \"option.h\"\n#include <cstring>\n#include <cstdint>\n\nnamespace {\nconstexpr int N = 1280;\nconstexpr int K = 960;\nconstexpr float input_scale = 0.01;\n\n// create_pipeline (int8 weight quantize/repack) is expensive and depends only\n// on the weights, which are constant across bench's 56 reps per workload but\n// CHANGE between workloads (bench reuses the input buffers, so pointers are\n// stable \u2014 can't key on them). Hoist create_pipeline into a cache keyed on a\n// cheap content hash of weight_scales (4KB, changes per workload) so it runs\n// once per workload (in the untimed warmup) and the 50 timed reps run only\n// forward(); otherwise the repack dominates timing and the \"expert\" baseline\n// looks ~14x slower than it is.\ninline uint64_t fnv1a(const void* p, size_t n) {\n    const unsigned char* b = (const unsigned char*)p;\n    uint64_t h = 1469598103934665603ULL;\n    for (size_t i = 0; i < n; ++i) { h ^= b[i]; h *= 1099511628211ULL; }\n    return h;\n}\nstruct Cache {\n    ncnn::InnerProduct_arm ip;\n    ncnn::Mat wscale, bscale;\n    ncnn::Option opt;\n    uint64_t key = 0;\n    bool built = false;\n};\nCache g;\n} // namespace\n\nint ncnn::gemm_w8a8ch_kernel(\n    const Mat& A, Mat& top,\n    const Mat& B, const Mat& weight_scales,\n    const Option& opt)\n{\n    const uint64_t key = fnv1a(weight_scales.data, (size_t)N * sizeof(float));\n    if (!g.built || g.key != key) {\n        if (g.built) { g.ip.destroy_pipeline(g.opt); g.built = false; }\n        // ncnn int8 scale fields are *quantization* multipliers; this baseline's\n        // scales are *dequantization* multipliers \u2014 invert them.\n        g.wscale.create(N, (size_t)4u);\n        if (g.wscale.empty()) return -1;\n        const float* ws = (const float*)weight_scales.data;\n        for (int p = 0; p < N; ++p) g.wscale[p] = 1.0f / ws[p];\n        g.bscale.create(1, (size_t)4u);\n        if (g.bscale.empty()) return -1;\n        g.bscale[0] = 1.0f / input_scale;\n        g.ip.num_output          = N;\n        g.ip.bias_term           = 0;\n        g.ip.weight_data_size    = N * K;\n        g.ip.int8_scale_term     = 1;\n        g.ip.activation_type     = 0;\n        g.ip.activation_params   = Mat();\n        g.ip.weight_data             = const_cast<Mat&>(B);\n        g.ip.weight_data_int8_scales = g.wscale;\n        g.ip.bottom_blob_int8_scales = g.bscale;\n        if (g.ip.create_pipeline(opt) != 0) return -1;\n        g.opt = opt; g.key = key; g.built = true;\n    }\n\n    Mat local_top_fp32;\n    if (g.ip.forward(A, local_top_fp32, opt) != 0) return -1;\n    const int M = top.h;\n    for (int m = 0; m < M; ++m)\n        std::memcpy((float*)top.row(m), local_top_fp32.row(m), N * sizeof(float));\n    return 0;\n}\n"
-    }
-  ]
-}

solutions/ncnn/claude-sonnet-4-6/gemm/gemm_fp32_n1000_k1280.json

@@ -1,38 +0,0 @@
-{
-  "name": "claude-sonnet-4-6_gemm_fp32_n1000_k1280",
-  "definition": "gemm_fp32_n1000_k1280",
-  "dataset": "ncnn",
-  "author": "claude-sonnet-4-6",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [
-      "sve"
-    ],
-    "compile_flags": [
-      "-O3",
-      "-march=armv8.2-a+sve",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n\n// Per-definition constants for this gemm specialisation.\n// C[m, n] = sum_k A[m, k] * B[n, k]  (B is the [N, K] \"weight\" matrix, transposed)\nnamespace gemm_def {\nconstexpr int N = 1000;\nconstexpr int K = 1280;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K); B: (N, K); output: (M, N).\nvoid inner_gemm(const float* A, float* output, const float* B, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, int M)\n{\n    inner_gemm(A, output, B, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "\n#include \"gemm.h\"\n#include <arm_sve.h>\n#include <cstring>\n\nusing namespace gemm_def;\n\n// Optimized GEMM: C[m,n] = sum_k A[m,k] * B[n,k]\n// Strategy: tile over M and N, use SVE to vectorize over K\n// Use 4x4 register blocking: 4 rows of A x 4 rows of B\n// Each accumulator is a scalar (dot product result)\n// Actually, since K=1280 is large, we vectorize over K dimension\n\nextern \"C\" void inner_gemm(const float* A, float* output, const float* B, int M)\n{\n    // We'll process multiple output rows at once\n    // For each m, compute dot products with all N rows of B\n    // Tile: process 4 rows of A at a time, 4 rows of B at a time\n    \n    const int MR = 4; // rows of A per tile\n    const int NR = 4; // rows of B per tile\n    \n    int m = 0;\n    for (; m + MR <= M; m += MR) {\n        const float* a0 = A + (long)(m+0) * K;\n        const float* a1 = A + (long)(m+1) * K;\n        const float* a2 = A + (long)(m+2) * K;\n        const float* a3 = A + (long)(m+3) * K;\n        \n        int n = 0;\n        for (; n + NR <= N; n += NR) {\n            const float* b0 = B + (long)(n+0) * K;\n            const float* b1 = B + (long)(n+1) * K;\n            const float* b2 = B + (long)(n+2) * K;\n            const float* b3 = B + (long)(n+3) * K;\n            \n            svfloat32_t acc00 = svdup_f32(0.0f);\n            svfloat32_t acc01 = svdup_f32(0.0f);\n            svfloat32_t acc02 = svdup_f32(0.0f);\n            svfloat32_t acc03 = svdup_f32(0.0f);\n            svfloat32_t acc10 = svdup_f32(0.0f);\n            svfloat32_t acc11 = svdup_f32(0.0f);\n            svfloat32_t acc12 = svdup_f32(0.0f);\n            svfloat32_t acc13 = svdup_f32(0.0f);\n            svfloat32_t acc20 = svdup_f32(0.0f);\n            svfloat32_t acc21 = svdup_f32(0.0f);\n            svfloat32_t acc22 = svdup_f32(0.0f);\n            svfloat32_t acc23 = svdup_f32(0.0f);\n            svfloat32_t acc30 = svdup_f32(0.0f);\n            svfloat32_t acc31 = svdup_f32(0.0f);\n            svfloat32_t acc32 = svdup_f32(0.0f);\n            svfloat32_t acc33 = svdup_f32(0.0f);\n            \n            svbool_t pg = svptrue_b32();\n            int k = 0;\n            int vl = svcntw();\n            \n            for (; k + (int)vl <= K; k += vl) {\n                svfloat32_t va0 = svld1_f32(pg, a0 + k);\n                svfloat32_t va1 = svld1_f32(pg, a1 + k);\n                svfloat32_t va2 = svld1_f32(pg, a2 + k);\n                svfloat32_t va3 = svld1_f32(pg, a3 + k);\n                svfloat32_t vb0 = svld1_f32(pg, b0 + k);\n                svfloat32_t vb1 = svld1_f32(pg, b1 + k);\n                svfloat32_t vb2 = svld1_f32(pg, b2 + k);\n                svfloat32_t vb3 = svld1_f32(pg, b3 + k);\n                \n                acc00 = svmla_f32_x(pg, acc00, va0, vb0);\n                acc01 = svmla_f32_x(pg, acc01, va0, vb1);\n                acc02 = svmla_f32_x(pg, acc02, va0, vb2);\n                acc03 = svmla_f32_x(pg, acc03, va0, vb3);\n                acc10 = svmla_f32_x(pg, acc10, va1, vb0);\n                acc11 = svmla_f32_x(pg, acc11, va1, vb1);\n                acc12 = svmla_f32_x(pg, acc12, va1, vb2);\n                acc13 = svmla_f32_x(pg, acc13, va1, vb3);\n                acc20 = svmla_f32_x(pg, acc20, va2, vb0);\n                acc21 = svmla_f32_x(pg, acc21, va2, vb1);\n                acc22 = svmla_f32_x(pg, acc22, va2, vb2);\n                acc23 = svmla_f32_x(pg, acc23, va2, vb3);\n                acc30 = svmla_f32_x(pg, acc30, va3, vb0);\n                acc31 = svmla_f32_x(pg, acc31, va3, vb1);\n                acc32 = svmla_f32_x(pg, acc32, va3, vb2);\n                acc33 = svmla_f32_x(pg, acc33, va3, vb3);\n            }\n            \n            // Handle tail\n            if (k < K) {\n                svbool_t ptail = svwhilelt_b32(k, K);\n                svfloat32_t va0 = svld1_f32(ptail, a0 + k);\n                svfloat32_t va1 = svld1_f32(ptail, a1 + k);\n                svfloat32_t va2 = svld1_f32(ptail, a2 + k);\n                svfloat32_t va3 = svld1_f32(ptail, a3 + k);\n                svfloat32_t vb0 = svld1_f32(ptail, b0 + k);\n                svfloat32_t vb1 = svld1_f32(ptail, b1 + k);\n                svfloat32_t vb2 = svld1_f32(ptail, b2 + k);\n                svfloat32_t vb3 = svld1_f32(ptail, b3 + k);\n                \n                acc00 = svmla_f32_x(ptail, acc00, va0, vb0);\n                acc01 = svmla_f32_x(ptail, acc01, va0, vb1);\n                acc02 = svmla_f32_x(ptail, acc02, va0, vb2);\n                acc03 = svmla_f32_x(ptail, acc03, va0, vb3);\n                acc10 = svmla_f32_x(ptail, acc10, va1, vb0);\n                acc11 = svmla_f32_x(ptail, acc11, va1, vb1);\n                acc12 = svmla_f32_x(ptail, acc12, va1, vb2);\n                acc13 = svmla_f32_x(ptail, acc13, va1, vb3);\n                acc20 = svmla_f32_x(ptail, acc20, va2, vb0);\n                acc21 = svmla_f32_x(ptail, acc21, va2, vb1);\n                acc22 = svmla_f32_x(ptail, acc22, va2, vb2);\n                acc23 = svmla_f32_x(ptail, acc23, va2, vb3);\n                acc30 = svmla_f32_x(ptail, acc30, va3, vb0);\n                acc31 = svmla_f32_x(ptail, acc31, va3, vb1);\n                acc32 = svmla_f32_x(ptail, acc32, va3, vb2);\n                acc33 = svmla_f32_x(ptail, acc33, va3, vb3);\n            }\n            \n            // Reduce accumulators\n            float* out0 = output + (long)(m+0) * N + n;\n            float* out1 = output + (long)(m+1) * N + n;\n            float* out2 = output + (long)(m+2) * N + n;\n            float* out3 = output + (long)(m+3) * N + n;\n            \n            out0[0] = svaddv_f32(svptrue_b32(), acc00);\n            out0[1] = svaddv_f32(svptrue_b32(), acc01);\n            out0[2] = svaddv_f32(svptrue_b32(), acc02);\n            out0[3] = svaddv_f32(svptrue_b32(), acc03);\n            out1[0] = svaddv_f32(svptrue_b32(), acc10);\n            out1[1] = svaddv_f32(svptrue_b32(), acc11);\n            out1[2] = svaddv_f32(svptrue_b32(), acc12);\n            out1[3] = svaddv_f32(svptrue_b32(), acc13);\n            out2[0] = svaddv_f32(svptrue_b32(), acc20);\n            out2[1] = svaddv_f32(svptrue_b32(), acc21);\n            out2[2] = svaddv_f32(svptrue_b32(), acc22);\n            out2[3] = svaddv_f32(svptrue_b32(), acc23);\n            out3[0] = svaddv_f32(svptrue_b32(), acc30);\n            out3[1] = svaddv_f32(svptrue_b32(), acc31);\n            out3[2] = svaddv_f32(svptrue_b32(), acc32);\n            out3[3] = svaddv_f32(svptrue_b32(), acc33);\n        }\n        \n        // Handle remaining n\n        for (; n < N; ++n) {\n            const float* b_row = B + (long)n * K;\n            svfloat32_t acc0 = svdup_f32(0.0f);\n            svfloat32_t acc1 = svdup_f32(0.0f);\n            svfloat32_t acc2 = svdup_f32(0.0f);\n            svfloat32_t acc3 = svdup_f32(0.0f);\n            svbool_t pg = svptrue_b32();\n            int vl = svcntw();\n            int k = 0;\n            for (; k + (int)vl <= K; k += vl) {\n                svfloat32_t vb = svld1_f32(pg, b_row + k);\n                acc0 = svmla_f32_x(pg, acc0, svld1_f32(pg, a0 + k), vb);\n                acc1 = svmla_f32_x(pg, acc1, svld1_f32(pg, a1 + k), vb);\n                acc2 = svmla_f32_x(pg, acc2, svld1_f32(pg, a2 + k), vb);\n                acc3 = svmla_f32_x(pg, acc3, svld1_f32(pg, a3 + k), vb);\n            }\n            if (k < K) {\n                svbool_t ptail = svwhilelt_b32(k, K);\n                svfloat32_t vb = svld1_f32(ptail, b_row + k);\n                acc0 = svmla_f32_x(ptail, acc0, svld1_f32(ptail, a0 + k), vb);\n                acc1 = svmla_f32_x(ptail, acc1, svld1_f32(ptail, a1 + k), vb);\n                acc2 = svmla_f32_x(ptail, acc2, svld1_f32(ptail, a2 + k), vb);\n                acc3 = svmla_f32_x(ptail, acc3, svld1_f32(ptail, a3 + k), vb);\n            }\n            output[(long)(m+0)*N + n] = svaddv_f32(svptrue_b32(), acc0);\n            output[(long)(m+1)*N + n] = svaddv_f32(svptrue_b32(), acc1);\n            output[(long)(m+2)*N + n] = svaddv_f32(svptrue_b32(), acc2);\n            output[(long)(m+3)*N + n] = svaddv_f32(svptrue_b32(), acc3);\n        }\n    }\n    \n    // Handle remaining m rows\n    for (; m < M; ++m) {\n        const float* a_row = A + (long)m * K;\n        float* out_row = output + (long)m * N;\n        int n = 0;\n        for (; n < N; ++n) {\n            const float* b_row = B + (long)n * K;\n            svfloat32_t acc = svdup_f32(0.0f);\n            svbool_t pg = svptrue_b32();\n            int vl = svcntw();\n            int k = 0;\n            for (; k + (int)vl <= K; k += vl) {\n                acc = svmla_f32_x(pg, acc, svld1_f32(pg, a_row + k), svld1_f32(pg, b_row + k));\n            }\n            if (k < K) {\n                svbool_t ptail = svwhilelt_b32(k, K);\n                acc = svmla_f32_x(ptail, acc, svld1_f32(ptail, a_row + k), svld1_f32(ptail, b_row + k));\n            }\n            out_row[n] = svaddv_f32(svptrue_b32(), acc);\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/claude-sonnet-4-6/gemm/gemm_fp32_n1000_k2048.json

@@ -1,38 +0,0 @@
-{
-  "name": "claude-sonnet-4-6_gemm_fp32_n1000_k2048",
-  "definition": "gemm_fp32_n1000_k2048",
-  "dataset": "ncnn",
-  "author": "claude-sonnet-4-6",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [
-      "sve"
-    ],
-    "compile_flags": [
-      "-O3",
-      "-march=armv8.2-a+sve",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n\n// Per-definition constants for this gemm specialisation.\n// C[m, n] = sum_k A[m, k] * B[n, k]  (B is the [N, K] \"weight\" matrix, transposed)\nnamespace gemm_def {\nconstexpr int N = 1000;\nconstexpr int K = 2048;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K); B: (N, K); output: (M, N).\nvoid inner_gemm(const float* A, float* output, const float* B, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, int M)\n{\n    inner_gemm(A, output, B, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "\n#include \"gemm.h\"\n#include <arm_sve.h>\n#include <cstring>\n\nusing namespace gemm_def;\n\n// Optimized GEMM: C[M,N] = A[M,K] * B[N,K]^T\n// Strategy: tile over M and N, use SVE to vectorize the K reduction\n// Use 4x4 blocking over M and N with SVE accumulators\n\nextern \"C\" void inner_gemm(const float* A, float* output, const float* B, int M)\n{\n    // SVE vector length in floats\n    const int vl = svcntw();\n\n    // We'll do M-blocking of 4 rows at a time, N-blocking of 4 cols at a time\n    // For each (m_block, n_block), accumulate over K using SVE\n\n    const int M_BLOCK = 4;\n    const int N_BLOCK = 4;\n\n    int m = 0;\n    for (; m + M_BLOCK <= M; m += M_BLOCK) {\n        int n = 0;\n        for (; n + N_BLOCK <= N; n += N_BLOCK) {\n            // 4x4 tile: accumulators for rows m..m+3, cols n..n+3\n            svfloat32_t acc00 = svdup_f32(0.0f);\n            svfloat32_t acc01 = svdup_f32(0.0f);\n            svfloat32_t acc02 = svdup_f32(0.0f);\n            svfloat32_t acc03 = svdup_f32(0.0f);\n            svfloat32_t acc10 = svdup_f32(0.0f);\n            svfloat32_t acc11 = svdup_f32(0.0f);\n            svfloat32_t acc12 = svdup_f32(0.0f);\n            svfloat32_t acc13 = svdup_f32(0.0f);\n            svfloat32_t acc20 = svdup_f32(0.0f);\n            svfloat32_t acc21 = svdup_f32(0.0f);\n            svfloat32_t acc22 = svdup_f32(0.0f);\n            svfloat32_t acc23 = svdup_f32(0.0f);\n            svfloat32_t acc30 = svdup_f32(0.0f);\n            svfloat32_t acc31 = svdup_f32(0.0f);\n            svfloat32_t acc32 = svdup_f32(0.0f);\n            svfloat32_t acc33 = svdup_f32(0.0f);\n\n            const float* a0 = A + (long)(m+0) * K;\n            const float* a1 = A + (long)(m+1) * K;\n            const float* a2 = A + (long)(m+2) * K;\n            const float* a3 = A + (long)(m+3) * K;\n            const float* b0 = B + (long)(n+0) * K;\n            const float* b1 = B + (long)(n+1) * K;\n            const float* b2 = B + (long)(n+2) * K;\n            const float* b3 = B + (long)(n+3) * K;\n\n            svbool_t pg = svptrue_b32();\n            for (int k = 0; k < K; k += vl) {\n                svbool_t pred = svwhilelt_b32(k, K);\n                svfloat32_t va0 = svld1_f32(pred, a0 + k);\n                svfloat32_t va1 = svld1_f32(pred, a1 + k);\n                svfloat32_t va2 = svld1_f32(pred, a2 + k);\n                svfloat32_t va3 = svld1_f32(pred, a3 + k);\n                svfloat32_t vb0 = svld1_f32(pred, b0 + k);\n                svfloat32_t vb1 = svld1_f32(pred, b1 + k);\n                svfloat32_t vb2 = svld1_f32(pred, b2 + k);\n                svfloat32_t vb3 = svld1_f32(pred, b3 + k);\n\n                acc00 = svmla_f32_m(pred, acc00, va0, vb0);\n                acc01 = svmla_f32_m(pred, acc01, va0, vb1);\n                acc02 = svmla_f32_m(pred, acc02, va0, vb2);\n                acc03 = svmla_f32_m(pred, acc03, va0, vb3);\n\n                acc10 = svmla_f32_m(pred, acc10, va1, vb0);\n                acc11 = svmla_f32_m(pred, acc11, va1, vb1);\n                acc12 = svmla_f32_m(pred, acc12, va1, vb2);\n                acc13 = svmla_f32_m(pred, acc13, va1, vb3);\n\n                acc20 = svmla_f32_m(pred, acc20, va2, vb0);\n                acc21 = svmla_f32_m(pred, acc21, va2, vb1);\n                acc22 = svmla_f32_m(pred, acc22, va2, vb2);\n                acc23 = svmla_f32_m(pred, acc23, va2, vb3);\n\n                acc30 = svmla_f32_m(pred, acc30, va3, vb0);\n                acc31 = svmla_f32_m(pred, acc31, va3, vb1);\n                acc32 = svmla_f32_m(pred, acc32, va3, vb2);\n                acc33 = svmla_f32_m(pred, acc33, va3, vb3);\n            }\n\n            // Horizontal reduce and store\n            float* out0 = output + (long)(m+0) * N;\n            float* out1 = output + (long)(m+1) * N;\n            float* out2 = output + (long)(m+2) * N;\n            float* out3 = output + (long)(m+3) * N;\n\n            out0[n+0] = svaddv_f32(svptrue_b32(), acc00);\n            out0[n+1] = svaddv_f32(svptrue_b32(), acc01);\n            out0[n+2] = svaddv_f32(svptrue_b32(), acc02);\n            out0[n+3] = svaddv_f32(svptrue_b32(), acc03);\n\n            out1[n+0] = svaddv_f32(svptrue_b32(), acc10);\n            out1[n+1] = svaddv_f32(svptrue_b32(), acc11);\n            out1[n+2] = svaddv_f32(svptrue_b32(), acc12);\n            out1[n+3] = svaddv_f32(svptrue_b32(), acc13);\n\n            out2[n+0] = svaddv_f32(svptrue_b32(), acc20);\n            out2[n+1] = svaddv_f32(svptrue_b32(), acc21);\n            out2[n+2] = svaddv_f32(svptrue_b32(), acc22);\n            out2[n+3] = svaddv_f32(svptrue_b32(), acc23);\n\n            out3[n+0] = svaddv_f32(svptrue_b32(), acc30);\n            out3[n+1] = svaddv_f32(svptrue_b32(), acc31);\n            out3[n+2] = svaddv_f32(svptrue_b32(), acc32);\n            out3[n+3] = svaddv_f32(svptrue_b32(), acc33);\n        }\n\n        // Remainder N\n        for (; n < N; ++n) {\n            float sum0 = 0.0f, sum1 = 0.0f, sum2 = 0.0f, sum3 = 0.0f;\n            const float* a0 = A + (long)(m+0) * K;\n            const float* a1 = A + (long)(m+1) * K;\n            const float* a2 = A + (long)(m+2) * K;\n            const float* a3 = A + (long)(m+3) * K;\n            const float* b0 = B + (long)n * K;\n            svbool_t pg = svptrue_b32();\n            svfloat32_t acc0 = svdup_f32(0.0f);\n            svfloat32_t acc1 = svdup_f32(0.0f);\n            svfloat32_t acc2 = svdup_f32(0.0f);\n            svfloat32_t acc3 = svdup_f32(0.0f);\n            for (int k = 0; k < K; k += vl) {\n                svbool_t pred = svwhilelt_b32(k, K);\n                svfloat32_t va0 = svld1_f32(pred, a0 + k);\n                svfloat32_t va1 = svld1_f32(pred, a1 + k);\n                svfloat32_t va2 = svld1_f32(pred, a2 + k);\n                svfloat32_t va3 = svld1_f32(pred, a3 + k);\n                svfloat32_t vb = svld1_f32(pred, b0 + k);\n                acc0 = svmla_f32_m(pred, acc0, va0, vb);\n                acc1 = svmla_f32_m(pred, acc1, va1, vb);\n                acc2 = svmla_f32_m(pred, acc2, va2, vb);\n                acc3 = svmla_f32_m(pred, acc3, va3, vb);\n            }\n            output[(long)(m+0)*N + n] = svaddv_f32(svptrue_b32(), acc0);\n            output[(long)(m+1)*N + n] = svaddv_f32(svptrue_b32(), acc1);\n            output[(long)(m+2)*N + n] = svaddv_f32(svptrue_b32(), acc2);\n            output[(long)(m+3)*N + n] = svaddv_f32(svptrue_b32(), acc3);\n        }\n    }\n\n    // Remainder M\n    for (; m < M; ++m) {\n        const float* a0 = A + (long)m * K;\n        float* out0 = output + (long)m * N;\n        int n = 0;\n        for (; n + N_BLOCK <= N; n += N_BLOCK) {\n            svfloat32_t acc0 = svdup_f32(0.0f);\n            svfloat32_t acc1 = svdup_f32(0.0f);\n            svfloat32_t acc2 = svdup_f32(0.0f);\n            svfloat32_t acc3 = svdup_f32(0.0f);\n            const float* b0 = B + (long)(n+0) * K;\n            const float* b1 = B + (long)(n+1) * K;\n            const float* b2 = B + (long)(n+2) * K;\n            const float* b3 = B + (long)(n+3) * K;\n            for (int k = 0; k < K; k += vl) {\n                svbool_t pred = svwhilelt_b32(k, K);\n                svfloat32_t va = svld1_f32(pred, a0 + k);\n                svfloat32_t vb0 = svld1_f32(pred, b0 + k);\n                svfloat32_t vb1 = svld1_f32(pred, b1 + k);\n                svfloat32_t vb2 = svld1_f32(pred, b2 + k);\n                svfloat32_t vb3 = svld1_f32(pred, b3 + k);\n                acc0 = svmla_f32_m(pred, acc0, va, vb0);\n                acc1 = svmla_f32_m(pred, acc1, va, vb1);\n                acc2 = svmla_f32_m(pred, acc2, va, vb2);\n                acc3 = svmla_f32_m(pred, acc3, va, vb3);\n            }\n            out0[n+0] = svaddv_f32(svptrue_b32(), acc0);\n            out0[n+1] = svaddv_f32(svptrue_b32(), acc1);\n            out0[n+2] = svaddv_f32(svptrue_b32(), acc2);\n            out0[n+3] = svaddv_f32(svptrue_b32(), acc3);\n        }\n        for (; n < N; ++n) {\n            svfloat32_t acc = svdup_f32(0.0f);\n            const float* b0 = B + (long)n * K;\n            for (int k = 0; k < K; k += vl) {\n                svbool_t pred = svwhilelt_b32(k, K);\n                svfloat32_t va = svld1_f32(pred, a0 + k);\n                svfloat32_t vb = svld1_f32(pred, b0 + k);\n                acc = svmla_f32_m(pred, acc, va, vb);\n            }\n            out0[n] = svaddv_f32(svptrue_b32(), acc);\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/claude-sonnet-4-6/gemm/gemm_fp32_n1280_k960.json

@@ -1,38 +0,0 @@
-{
-  "name": "claude-sonnet-4-6_gemm_fp32_n1280_k960",
-  "definition": "gemm_fp32_n1280_k960",
-  "dataset": "ncnn",
-  "author": "claude-sonnet-4-6",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [
-      "sve"
-    ],
-    "compile_flags": [
-      "-O3",
-      "-march=armv8.2-a+sve",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n\n// Per-definition constants for this gemm specialisation.\n// C[m, n] = sum_k A[m, k] * B[n, k]  (B is the [N, K] \"weight\" matrix, transposed)\nnamespace gemm_def {\nconstexpr int N = 1280;\nconstexpr int K = 960;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K); B: (N, K); output: (M, N).\nvoid inner_gemm(const float* A, float* output, const float* B, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, int M)\n{\n    inner_gemm(A, output, B, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "\n#include \"gemm.h\"\n#include <arm_sve.h>\n#include <cstring>\n\nusing namespace gemm_def;\n\n// Optimized GEMM: C[m,n] = sum_k A[m,k] * B[n,k]\n// Strategy: tile over M and N, use SVE to vectorize over K\n// Use 4x4 register blocking: process 4 rows of A and 4 rows of B simultaneously\n// Each accumulator is a scalar (dot product result)\n\nextern \"C\" void inner_gemm(const float* A, float* output, const float* B, int M)\n{\n    // We'll use a tile approach: for each block of M rows and N cols,\n    // accumulate dot products using SVE fmla over K dimension.\n    \n    // Tile sizes\n    const int MR = 4;  // rows of A per tile\n    const int NR = 8;  // rows of B per tile (output cols)\n    \n    int m = 0;\n    for (; m + MR <= M; m += MR) {\n        const float* a0 = A + (long)(m+0) * K;\n        const float* a1 = A + (long)(m+1) * K;\n        const float* a2 = A + (long)(m+2) * K;\n        const float* a3 = A + (long)(m+3) * K;\n        \n        float* out0 = output + (long)(m+0) * N;\n        float* out1 = output + (long)(m+1) * N;\n        float* out2 = output + (long)(m+2) * N;\n        float* out3 = output + (long)(m+3) * N;\n        \n        int n = 0;\n        for (; n + NR <= N; n += NR) {\n            const float* b0 = B + (long)(n+0) * K;\n            const float* b1 = B + (long)(n+1) * K;\n            const float* b2 = B + (long)(n+2) * K;\n            const float* b3 = B + (long)(n+3) * K;\n            const float* b4 = B + (long)(n+4) * K;\n            const float* b5 = B + (long)(n+5) * K;\n            const float* b6 = B + (long)(n+6) * K;\n            const float* b7 = B + (long)(n+7) * K;\n            \n            // 4x8 accumulators\n            svfloat32_t acc00 = svdup_f32(0.0f);\n            svfloat32_t acc01 = svdup_f32(0.0f);\n            svfloat32_t acc02 = svdup_f32(0.0f);\n            svfloat32_t acc03 = svdup_f32(0.0f);\n            svfloat32_t acc04 = svdup_f32(0.0f);\n            svfloat32_t acc05 = svdup_f32(0.0f);\n            svfloat32_t acc06 = svdup_f32(0.0f);\n            svfloat32_t acc07 = svdup_f32(0.0f);\n            \n            svfloat32_t acc10 = svdup_f32(0.0f);\n            svfloat32_t acc11 = svdup_f32(0.0f);\n            svfloat32_t acc12 = svdup_f32(0.0f);\n            svfloat32_t acc13 = svdup_f32(0.0f);\n            svfloat32_t acc14 = svdup_f32(0.0f);\n            svfloat32_t acc15 = svdup_f32(0.0f);\n            svfloat32_t acc16 = svdup_f32(0.0f);\n            svfloat32_t acc17 = svdup_f32(0.0f);\n            \n            svfloat32_t acc20 = svdup_f32(0.0f);\n            svfloat32_t acc21 = svdup_f32(0.0f);\n            svfloat32_t acc22 = svdup_f32(0.0f);\n            svfloat32_t acc23 = svdup_f32(0.0f);\n            svfloat32_t acc24 = svdup_f32(0.0f);\n            svfloat32_t acc25 = svdup_f32(0.0f);\n            svfloat32_t acc26 = svdup_f32(0.0f);\n            svfloat32_t acc27 = svdup_f32(0.0f);\n            \n            svfloat32_t acc30 = svdup_f32(0.0f);\n            svfloat32_t acc31 = svdup_f32(0.0f);\n            svfloat32_t acc32 = svdup_f32(0.0f);\n            svfloat32_t acc33 = svdup_f32(0.0f);\n            svfloat32_t acc34 = svdup_f32(0.0f);\n            svfloat32_t acc35 = svdup_f32(0.0f);\n            svfloat32_t acc36 = svdup_f32(0.0f);\n            svfloat32_t acc37 = svdup_f32(0.0f);\n            \n            // Loop over K with SVE vectors\n            int k = 0;\n            svbool_t pg = svptrue_b32();\n            int vl = svcntw();\n            \n            for (; k + (int)vl <= K; k += vl) {\n                svfloat32_t va0 = svld1_f32(pg, a0 + k);\n                svfloat32_t va1 = svld1_f32(pg, a1 + k);\n                svfloat32_t va2 = svld1_f32(pg, a2 + k);\n                svfloat32_t va3 = svld1_f32(pg, a3 + k);\n                \n                svfloat32_t vb0 = svld1_f32(pg, b0 + k);\n                svfloat32_t vb1 = svld1_f32(pg, b1 + k);\n                svfloat32_t vb2 = svld1_f32(pg, b2 + k);\n                svfloat32_t vb3 = svld1_f32(pg, b3 + k);\n                svfloat32_t vb4 = svld1_f32(pg, b4 + k);\n                svfloat32_t vb5 = svld1_f32(pg, b5 + k);\n                svfloat32_t vb6 = svld1_f32(pg, b6 + k);\n                svfloat32_t vb7 = svld1_f32(pg, b7 + k);\n                \n                acc00 = svmla_f32_x(pg, acc00, va0, vb0);\n                acc01 = svmla_f32_x(pg, acc01, va0, vb1);\n                acc02 = svmla_f32_x(pg, acc02, va0, vb2);\n                acc03 = svmla_f32_x(pg, acc03, va0, vb3);\n                acc04 = svmla_f32_x(pg, acc04, va0, vb4);\n                acc05 = svmla_f32_x(pg, acc05, va0, vb5);\n                acc06 = svmla_f32_x(pg, acc06, va0, vb6);\n                acc07 = svmla_f32_x(pg, acc07, va0, vb7);\n                \n                acc10 = svmla_f32_x(pg, acc10, va1, vb0);\n                acc11 = svmla_f32_x(pg, acc11, va1, vb1);\n                acc12 = svmla_f32_x(pg, acc12, va1, vb2);\n                acc13 = svmla_f32_x(pg, acc13, va1, vb3);\n                acc14 = svmla_f32_x(pg, acc14, va1, vb4);\n                acc15 = svmla_f32_x(pg, acc15, va1, vb5);\n                acc16 = svmla_f32_x(pg, acc16, va1, vb6);\n                acc17 = svmla_f32_x(pg, acc17, va1, vb7);\n                \n                acc20 = svmla_f32_x(pg, acc20, va2, vb0);\n                acc21 = svmla_f32_x(pg, acc21, va2, vb1);\n                acc22 = svmla_f32_x(pg, acc22, va2, vb2);\n                acc23 = svmla_f32_x(pg, acc23, va2, vb3);\n                acc24 = svmla_f32_x(pg, acc24, va2, vb4);\n                acc25 = svmla_f32_x(pg, acc25, va2, vb5);\n                acc26 = svmla_f32_x(pg, acc26, va2, vb6);\n                acc27 = svmla_f32_x(pg, acc27, va2, vb7);\n                \n                acc30 = svmla_f32_x(pg, acc30, va3, vb0);\n                acc31 = svmla_f32_x(pg, acc31, va3, vb1);\n                acc32 = svmla_f32_x(pg, acc32, va3, vb2);\n                acc33 = svmla_f32_x(pg, acc33, va3, vb3);\n                acc34 = svmla_f32_x(pg, acc34, va3, vb4);\n                acc35 = svmla_f32_x(pg, acc35, va3, vb5);\n                acc36 = svmla_f32_x(pg, acc36, va3, vb6);\n                acc37 = svmla_f32_x(pg, acc37, va3, vb7);\n            }\n            \n            // Handle tail\n            if (k < K) {\n                svbool_t ptail = svwhilelt_b32(k, K);\n                svfloat32_t va0 = svld1_f32(ptail, a0 + k);\n                svfloat32_t va1 = svld1_f32(ptail, a1 + k);\n                svfloat32_t va2 = svld1_f32(ptail, a2 + k);\n                svfloat32_t va3 = svld1_f32(ptail, a3 + k);\n                \n                svfloat32_t vb0 = svld1_f32(ptail, b0 + k);\n                svfloat32_t vb1 = svld1_f32(ptail, b1 + k);\n                svfloat32_t vb2 = svld1_f32(ptail, b2 + k);\n                svfloat32_t vb3 = svld1_f32(ptail, b3 + k);\n                svfloat32_t vb4 = svld1_f32(ptail, b4 + k);\n                svfloat32_t vb5 = svld1_f32(ptail, b5 + k);\n                svfloat32_t vb6 = svld1_f32(ptail, b6 + k);\n                svfloat32_t vb7 = svld1_f32(ptail, b7 + k);\n                \n                acc00 = svmla_f32_m(ptail, acc00, va0, vb0);\n                acc01 = svmla_f32_m(ptail, acc01, va0, vb1);\n                acc02 = svmla_f32_m(ptail, acc02, va0, vb2);\n                acc03 = svmla_f32_m(ptail, acc03, va0, vb3);\n                acc04 = svmla_f32_m(ptail, acc04, va0, vb4);\n                acc05 = svmla_f32_m(ptail, acc05, va0, vb5);\n                acc06 = svmla_f32_m(ptail, acc06, va0, vb6);\n                acc07 = svmla_f32_m(ptail, acc07, va0, vb7);\n                \n                acc10 = svmla_f32_m(ptail, acc10, va1, vb0);\n                acc11 = svmla_f32_m(ptail, acc11, va1, vb1);\n                acc12 = svmla_f32_m(ptail, acc12, va1, vb2);\n                acc13 = svmla_f32_m(ptail, acc13, va1, vb3);\n                acc14 = svmla_f32_m(ptail, acc14, va1, vb4);\n                acc15 = svmla_f32_m(ptail, acc15, va1, vb5);\n                acc16 = svmla_f32_m(ptail, acc16, va1, vb6);\n                acc17 = svmla_f32_m(ptail, acc17, va1, vb7);\n                \n                acc20 = svmla_f32_m(ptail, acc20, va2, vb0);\n                acc21 = svmla_f32_m(ptail, acc21, va2, vb1);\n                acc22 = svmla_f32_m(ptail, acc22, va2, vb2);\n                acc23 = svmla_f32_m(ptail, acc23, va2, vb3);\n                acc24 = svmla_f32_m(ptail, acc24, va2, vb4);\n                acc25 = svmla_f32_m(ptail, acc25, va2, vb5);\n                acc26 = svmla_f32_m(ptail, acc26, va2, vb6);\n                acc27 = svmla_f32_m(ptail, acc27, va2, vb7);\n                \n                acc30 = svmla_f32_m(ptail, acc30, va3, vb0);\n                acc31 = svmla_f32_m(ptail, acc31, va3, vb1);\n                acc32 = svmla_f32_m(ptail, acc32, va3, vb2);\n                acc33 = svmla_f32_m(ptail, acc33, va3, vb3);\n                acc34 = svmla_f32_m(ptail, acc34, va3, vb4);\n                acc35 = svmla_f32_m(ptail, acc35, va3, vb5);\n                acc36 = svmla_f32_m(ptail, acc36, va3, vb6);\n                acc37 = svmla_f32_m(ptail, acc37, va3, vb7);\n            }\n            \n            // Horizontal reduce and store\n            out0[n+0] = svaddv_f32(svptrue_b32(), acc00);\n            out0[n+1] = svaddv_f32(svptrue_b32(), acc01);\n            out0[n+2] = svaddv_f32(svptrue_b32(), acc02);\n            out0[n+3] = svaddv_f32(svptrue_b32(), acc03);\n            out0[n+4] = svaddv_f32(svptrue_b32(), acc04);\n            out0[n+5] = svaddv_f32(svptrue_b32(), acc05);\n            out0[n+6] = svaddv_f32(svptrue_b32(), acc06);\n            out0[n+7] = svaddv_f32(svptrue_b32(), acc07);\n            \n            out1[n+0] = svaddv_f32(svptrue_b32(), acc10);\n            out1[n+1] = svaddv_f32(svptrue_b32(), acc11);\n            out1[n+2] = svaddv_f32(svptrue_b32(), acc12);\n            out1[n+3] = svaddv_f32(svptrue_b32(), acc13);\n            out1[n+4] = svaddv_f32(svptrue_b32(), acc14);\n            out1[n+5] = svaddv_f32(svptrue_b32(), acc15);\n            out1[n+6] = svaddv_f32(svptrue_b32(), acc16);\n            out1[n+7] = svaddv_f32(svptrue_b32(), acc17);\n            \n            out2[n+0] = svaddv_f32(svptrue_b32(), acc20);\n            out2[n+1] = svaddv_f32(svptrue_b32(), acc21);\n            out2[n+2] = svaddv_f32(svptrue_b32(), acc22);\n            out2[n+3] = svaddv_f32(svptrue_b32(), acc23);\n            out2[n+4] = svaddv_f32(svptrue_b32(), acc24);\n            out2[n+5] = svaddv_f32(svptrue_b32(), acc25);\n            out2[n+6] = svaddv_f32(svptrue_b32(), acc26);\n            out2[n+7] = svaddv_f32(svptrue_b32(), acc27);\n            \n            out3[n+0] = svaddv_f32(svptrue_b32(), acc30);\n            out3[n+1] = svaddv_f32(svptrue_b32(), acc31);\n            out3[n+2] = svaddv_f32(svptrue_b32(), acc32);\n            out3[n+3] = svaddv_f32(svptrue_b32(), acc33);\n            out3[n+4] = svaddv_f32(svptrue_b32(), acc34);\n            out3[n+5] = svaddv_f32(svptrue_b32(), acc35);\n            out3[n+6] = svaddv_f32(svptrue_b32(), acc36);\n            out3[n+7] = svaddv_f32(svptrue_b32(), acc37);\n        }\n        \n        // Handle remaining N\n        for (; n < N; ++n) {\n            const float* b_row = B + (long)n * K;\n            float s0 = 0, s1 = 0, s2 = 0, s3 = 0;\n            svbool_t pg = svptrue_b32();\n            int vl = svcntw();\n            svfloat32_t vacc0 = svdup_f32(0.0f);\n            svfloat32_t vacc1 = svdup_f32(0.0f);\n            svfloat32_t vacc2 = svdup_f32(0.0f);\n            svfloat32_t vacc3 = svdup_f32(0.0f);\n            int k = 0;\n            for (; k + (int)vl <= K; k += vl) {\n                svfloat32_t vb = svld1_f32(pg, b_row + k);\n                vacc0 = svmla_f32_x(pg, vacc0, svld1_f32(pg, a0 + k), vb);\n                vacc1 = svmla_f32_x(pg, vacc1, svld1_f32(pg, a1 + k), vb);\n                vacc2 = svmla_f32_x(pg, vacc2, svld1_f32(pg, a2 + k), vb);\n                vacc3 = svmla_f32_x(pg, vacc3, svld1_f32(pg, a3 + k), vb);\n            }\n            if (k < K) {\n                svbool_t ptail = svwhilelt_b32(k, K);\n                svfloat32_t vb = svld1_f32(ptail, b_row + k);\n                vacc0 = svmla_f32_m(ptail, vacc0, svld1_f32(ptail, a0 + k), vb);\n                vacc1 = svmla_f32_m(ptail, vacc1, svld1_f32(ptail, a1 + k), vb);\n                vacc2 = svmla_f32_m(ptail, vacc2, svld1_f32(ptail, a2 + k), vb);\n                vacc3 = svmla_f32_m(ptail, vacc3, svld1_f32(ptail, a3 + k), vb);\n            }\n            out0[n] = svaddv_f32(svptrue_b32(), vacc0);\n            out1[n] = svaddv_f32(svptrue_b32(), vacc1);\n            out2[n] = svaddv_f32(svptrue_b32(), vacc2);\n            out3[n] = svaddv_f32(svptrue_b32(), vacc3);\n        }\n    }\n    \n    // Handle remaining M rows\n    for (; m < M; ++m) {\n        const float* a_row = A + (long)m * K;\n        float* out_row = output + (long)m * N;\n        svbool_t pg = svptrue_b32();\n        int vl = svcntw();\n        \n        for (int n = 0; n < N; ++n) {\n            const float* b_row = B + (long)n * K;\n            svfloat32_t vacc = svdup_f32(0.0f);\n            int k = 0;\n            for (; k + (int)vl <= K; k += vl) {\n                svfloat32_t va = svld1_f32(pg, a_row + k);\n                svfloat32_t vb = svld1_f32(pg, b_row + k);\n                vacc = svmla_f32_x(pg, vacc, va, vb);\n            }\n            if (k < K) {\n                svbool_t ptail = svwhilelt_b32(k, K);\n                svfloat32_t va = svld1_f32(ptail, a_row + k);\n                svfloat32_t vb = svld1_f32(ptail, b_row + k);\n                vacc = svmla_f32_m(ptail, vacc, va, vb);\n            }\n            out_row[n] = svaddv_f32(svptrue_b32(), vacc);\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/claude-sonnet-4-6/gemm/gemm_fp32_n29_k800.json

@@ -1,38 +0,0 @@
-{
-  "name": "claude-sonnet-4-6_gemm_fp32_n29_k800",
-  "definition": "gemm_fp32_n29_k800",
-  "dataset": "ncnn",
-  "author": "claude-sonnet-4-6",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [
-      "sve"
-    ],
-    "compile_flags": [
-      "-O3",
-      "-march=armv8.2-a+sve",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n\n// Per-definition constants for this gemm specialisation.\n// C[m, n] = sum_k A[m, k] * B[n, k]  (B is the [N, K] \"weight\" matrix, transposed)\nnamespace gemm_def {\nconstexpr int N = 29;\nconstexpr int K = 800;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K); B: (N, K); output: (M, N).\nvoid inner_gemm(const float* A, float* output, const float* B, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, int M)\n{\n    inner_gemm(A, output, B, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm.h\"\n#include <arm_sve.h>\nusing namespace gemm_def;\n\n// Optimized GEMM: C[m,n] = sum_k A[m,k] * B[n,k]\n// N=29, K=800\n// Strategy:\n//   - Tile M by 4 (outer loop)\n//   - Tile N by 4 (inner loop) to amortize B loads across 4 A rows\n//   - Use multiple SVE accumulators per (m,n) pair to hide FMA latency\n//   - K=800 is divisible by 8 (SVE 256-bit = 8 floats), so no tail needed\n\nextern \"C\" void inner_gemm(const float* A, float* output, const float* B, int M)\n{\n    // SVE vector length in floats (256-bit = 8 floats on Graviton3)\n    const int vl = svcntw();\n    svbool_t pg = svptrue_b32();\n\n    // Process 4 rows of A at a time, 4 cols of B at a time\n    const int M4 = (M / 4) * 4;\n    const int N4 = (N / 4) * 4;  // N=29, so N4=28\n\n    int m = 0;\n    for (; m < M4; m += 4) {\n        const float* a0 = A + (long)(m+0) * K;\n        const float* a1 = A + (long)(m+1) * K;\n        const float* a2 = A + (long)(m+2) * K;\n        const float* a3 = A + (long)(m+3) * K;\n        float* out0 = output + (long)(m+0) * N;\n        float* out1 = output + (long)(m+1) * N;\n        float* out2 = output + (long)(m+2) * N;\n        float* out3 = output + (long)(m+3) * N;\n\n        // Process 4 B rows at a time\n        int n = 0;\n        for (; n < N4; n += 4) {\n            const float* b0 = B + (long)(n+0) * K;\n            const float* b1 = B + (long)(n+1) * K;\n            const float* b2 = B + (long)(n+2) * K;\n            const float* b3 = B + (long)(n+3) * K;\n\n            // 4x4 block: acc[m_idx][n_idx]\n            svfloat32_t acc00 = svdup_f32(0.f), acc01 = svdup_f32(0.f);\n            svfloat32_t acc02 = svdup_f32(0.f), acc03 = svdup_f32(0.f);\n            svfloat32_t acc10 = svdup_f32(0.f), acc11 = svdup_f32(0.f);\n            svfloat32_t acc12 = svdup_f32(0.f), acc13 = svdup_f32(0.f);\n            svfloat32_t acc20 = svdup_f32(0.f), acc21 = svdup_f32(0.f);\n            svfloat32_t acc22 = svdup_f32(0.f), acc23 = svdup_f32(0.f);\n            svfloat32_t acc30 = svdup_f32(0.f), acc31 = svdup_f32(0.f);\n            svfloat32_t acc32 = svdup_f32(0.f), acc33 = svdup_f32(0.f);\n\n            for (int k = 0; k < K; k += vl) {\n                svfloat32_t av0 = svld1_f32(pg, a0 + k);\n                svfloat32_t av1 = svld1_f32(pg, a1 + k);\n                svfloat32_t av2 = svld1_f32(pg, a2 + k);\n                svfloat32_t av3 = svld1_f32(pg, a3 + k);\n                svfloat32_t bv0 = svld1_f32(pg, b0 + k);\n                svfloat32_t bv1 = svld1_f32(pg, b1 + k);\n                svfloat32_t bv2 = svld1_f32(pg, b2 + k);\n                svfloat32_t bv3 = svld1_f32(pg, b3 + k);\n\n                acc00 = svmla_f32_m(pg, acc00, av0, bv0);\n                acc01 = svmla_f32_m(pg, acc01, av0, bv1);\n                acc02 = svmla_f32_m(pg, acc02, av0, bv2);\n                acc03 = svmla_f32_m(pg, acc03, av0, bv3);\n\n                acc10 = svmla_f32_m(pg, acc10, av1, bv0);\n                acc11 = svmla_f32_m(pg, acc11, av1, bv1);\n                acc12 = svmla_f32_m(pg, acc12, av1, bv2);\n                acc13 = svmla_f32_m(pg, acc13, av1, bv3);\n\n                acc20 = svmla_f32_m(pg, acc20, av2, bv0);\n                acc21 = svmla_f32_m(pg, acc21, av2, bv1);\n                acc22 = svmla_f32_m(pg, acc22, av2, bv2);\n                acc23 = svmla_f32_m(pg, acc23, av2, bv3);\n\n                acc30 = svmla_f32_m(pg, acc30, av3, bv0);\n                acc31 = svmla_f32_m(pg, acc31, av3, bv1);\n                acc32 = svmla_f32_m(pg, acc32, av3, bv2);\n                acc33 = svmla_f32_m(pg, acc33, av3, bv3);\n            }\n\n            out0[n+0] = svaddv_f32(pg, acc00);\n            out0[n+1] = svaddv_f32(pg, acc01);\n            out0[n+2] = svaddv_f32(pg, acc02);\n            out0[n+3] = svaddv_f32(pg, acc03);\n\n            out1[n+0] = svaddv_f32(pg, acc10);\n            out1[n+1] = svaddv_f32(pg, acc11);\n            out1[n+2] = svaddv_f32(pg, acc12);\n            out1[n+3] = svaddv_f32(pg, acc13);\n\n            out2[n+0] = svaddv_f32(pg, acc20);\n            out2[n+1] = svaddv_f32(pg, acc21);\n            out2[n+2] = svaddv_f32(pg, acc22);\n            out2[n+3] = svaddv_f32(pg, acc23);\n\n            out3[n+0] = svaddv_f32(pg, acc30);\n            out3[n+1] = svaddv_f32(pg, acc31);\n            out3[n+2] = svaddv_f32(pg, acc32);\n            out3[n+3] = svaddv_f32(pg, acc33);\n        }\n\n        // Handle remaining N columns (n=28 for N=29)\n        for (; n < N; ++n) {\n            const float* b = B + (long)n * K;\n            svfloat32_t s0 = svdup_f32(0.f), s1 = svdup_f32(0.f);\n            svfloat32_t s2 = svdup_f32(0.f), s3 = svdup_f32(0.f);\n            for (int k = 0; k < K; k += vl) {\n                svfloat32_t bv = svld1_f32(pg, b + k);\n                s0 = svmla_f32_m(pg, s0, svld1_f32(pg, a0 + k), bv);\n                s1 = svmla_f32_m(pg, s1, svld1_f32(pg, a1 + k), bv);\n                s2 = svmla_f32_m(pg, s2, svld1_f32(pg, a2 + k), bv);\n                s3 = svmla_f32_m(pg, s3, svld1_f32(pg, a3 + k), bv);\n            }\n            out0[n] = svaddv_f32(pg, s0);\n            out1[n] = svaddv_f32(pg, s1);\n            out2[n] = svaddv_f32(pg, s2);\n            out3[n] = svaddv_f32(pg, s3);\n        }\n    }\n\n    // Handle remaining M rows\n    for (; m < M; ++m) {\n        const float* a0 = A + (long)m * K;\n        float* out0 = output + (long)m * N;\n\n        int n = 0;\n        for (; n < N4; n += 4) {\n            const float* b0 = B + (long)(n+0) * K;\n            const float* b1 = B + (long)(n+1) * K;\n            const float* b2 = B + (long)(n+2) * K;\n            const float* b3 = B + (long)(n+3) * K;\n            svfloat32_t s0 = svdup_f32(0.f), s1 = svdup_f32(0.f);\n            svfloat32_t s2 = svdup_f32(0.f), s3 = svdup_f32(0.f);\n            for (int k = 0; k < K; k += vl) {\n                svfloat32_t av = svld1_f32(pg, a0 + k);\n                s0 = svmla_f32_m(pg, s0, av, svld1_f32(pg, b0 + k));\n                s1 = svmla_f32_m(pg, s1, av, svld1_f32(pg, b1 + k));\n                s2 = svmla_f32_m(pg, s2, av, svld1_f32(pg, b2 + k));\n                s3 = svmla_f32_m(pg, s3, av, svld1_f32(pg, b3 + k));\n            }\n            out0[n+0] = svaddv_f32(pg, s0);\n            out0[n+1] = svaddv_f32(pg, s1);\n            out0[n+2] = svaddv_f32(pg, s2);\n            out0[n+3] = svaddv_f32(pg, s3);\n        }\n        for (; n < N; ++n) {\n            const float* b = B + (long)n * K;\n            svfloat32_t s0 = svdup_f32(0.f);\n            for (int k = 0; k < K; k += vl) {\n                s0 = svmla_f32_m(pg, s0, svld1_f32(pg, a0 + k), svld1_f32(pg, b + k));\n            }\n            out0[n] = svaddv_f32(pg, s0);\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/claude-sonnet-4-6/gemm/gemm_w8a8ch_n1000_k1280.json

@@ -1,38 +0,0 @@
-{
-  "name": "claude-sonnet-4-6_gemm_w8a8ch_n1000_k1280",
-  "definition": "gemm_w8a8ch_n1000_k1280",
-  "dataset": "ncnn",
-  "author": "claude-sonnet-4-6",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [
-      "sve"
-    ],
-    "compile_flags": [
-      "-O3",
-      "-march=armv8.2-a+sve",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Per-definition constants for this gemm w8a8ch (int8) specialisation.\n// C[m, n] = (A[m,:] . B[n,:]) * (input_scale * weight_scales[n])  (no bias)\n// input_scale is a per-definition-constant dequant scalar (constant across every\n// workload — checked at generation time); weight_scales is a genuine runtime\n// per-output-channel tensor, passed as a regular float pointer below.\nnamespace gemm_def {\nconstexpr int N = 1000;\nconstexpr int K = 1280;\nconstexpr float input_scale = 0.01;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K) int8; B: (N, K) int8; weight_scales: (N) float32;\n// output: (M, N) float32.\n// Dequantization: real = int32_acc * scale, where scale = input_scale * weight_scales[n]\n// (NOT ncnn's quantization convention int8 = round(real * scale)).\nvoid inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                 const float* weight_scales, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, weight_scales*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const int8_t* A, float* output, const int8_t* B,\n                                    const float* weight_scales, int M)\n{\n    inner_gemm(A, output, B, weight_scales, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "\n#include \"gemm.h\"\n#include <arm_sve.h>\n#include <cstring>\n\nusing namespace gemm_def;\n\n// Optimized GEMM for int8 weights and activations with per-channel dequantization\n// Strategy:\n// - Process multiple output rows (M tiles) at once to amortize B loads\n// - Use SVE int8 dot product (sdot) for efficient accumulation\n// - Tile over N (output channels) to improve cache utilization\n// - Unroll K loop with SVE vectors\n\nextern \"C\" void inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                            const float* weight_scales, int M)\n{\n    // We'll process 4 rows of A at a time, and 4 columns of B at a time\n    // K=1280, N=1000\n    // SVE vector length: 256-bit = 32 bytes = 32 int8 elements\n    // sdot processes 4 int8 per lane -> 8 int32 accumulators per vector\n\n    const int MR = 4; // rows of A per tile\n    const int NR = 4; // cols of B per tile (output channels)\n\n    int m = 0;\n    for (; m + MR <= M; m += MR) {\n        const int8_t* a0 = A + (long)(m+0) * K;\n        const int8_t* a1 = A + (long)(m+1) * K;\n        const int8_t* a2 = A + (long)(m+2) * K;\n        const int8_t* a3 = A + (long)(m+3) * K;\n        float* out0 = output + (long)(m+0) * N;\n        float* out1 = output + (long)(m+1) * N;\n        float* out2 = output + (long)(m+2) * N;\n        float* out3 = output + (long)(m+3) * N;\n\n        int n = 0;\n        for (; n + NR <= N; n += NR) {\n            const int8_t* b0 = B + (long)(n+0) * K;\n            const int8_t* b1 = B + (long)(n+1) * K;\n            const int8_t* b2 = B + (long)(n+2) * K;\n            const int8_t* b3 = B + (long)(n+3) * K;\n\n            // Accumulators: acc[mi][ni]\n            int32_t acc00=0, acc01=0, acc02=0, acc03=0;\n            int32_t acc10=0, acc11=0, acc12=0, acc13=0;\n            int32_t acc20=0, acc21=0, acc22=0, acc23=0;\n            int32_t acc30=0, acc31=0, acc32=0, acc33=0;\n\n            // Use SVE sdot for K loop\n            // sdot: accumulate 4 int8 products into int32\n            svint32_t vacc00 = svdup_n_s32(0);\n            svint32_t vacc01 = svdup_n_s32(0);\n            svint32_t vacc02 = svdup_n_s32(0);\n            svint32_t vacc03 = svdup_n_s32(0);\n            svint32_t vacc10 = svdup_n_s32(0);\n            svint32_t vacc11 = svdup_n_s32(0);\n            svint32_t vacc12 = svdup_n_s32(0);\n            svint32_t vacc13 = svdup_n_s32(0);\n            svint32_t vacc20 = svdup_n_s32(0);\n            svint32_t vacc21 = svdup_n_s32(0);\n            svint32_t vacc22 = svdup_n_s32(0);\n            svint32_t vacc23 = svdup_n_s32(0);\n            svint32_t vacc30 = svdup_n_s32(0);\n            svint32_t vacc31 = svdup_n_s32(0);\n            svint32_t vacc32 = svdup_n_s32(0);\n            svint32_t vacc33 = svdup_n_s32(0);\n\n            svbool_t pg = svptrue_b8();\n            // K must be multiple of 4 for sdot (K=1280 is divisible by 4)\n            // SVE vector length in int32 elements\n            uint64_t vl = svcntw(); // number of int32 per vector\n            // Each sdot processes 4 int8 per int32 lane\n            // So we process vl*4 int8 per iteration\n\n            for (int k = 0; k < K; k += (int)(vl * 4)) {\n                svbool_t pg8 = svptrue_b8();\n                // Load int8 vectors (vl*4 bytes each)\n                svint8_t va0 = svld1_s8(pg8, a0 + k);\n                svint8_t va1 = svld1_s8(pg8, a1 + k);\n                svint8_t va2 = svld1_s8(pg8, a2 + k);\n                svint8_t va3 = svld1_s8(pg8, a3 + k);\n                svint8_t vb0 = svld1_s8(pg8, b0 + k);\n                svint8_t vb1 = svld1_s8(pg8, b1 + k);\n                svint8_t vb2 = svld1_s8(pg8, b2 + k);\n                svint8_t vb3 = svld1_s8(pg8, b3 + k);\n\n                vacc00 = svdot_s32(vacc00, va0, vb0);\n                vacc01 = svdot_s32(vacc01, va0, vb1);\n                vacc02 = svdot_s32(vacc02, va0, vb2);\n                vacc03 = svdot_s32(vacc03, va0, vb3);\n\n                vacc10 = svdot_s32(vacc10, va1, vb0);\n                vacc11 = svdot_s32(vacc11, va1, vb1);\n                vacc12 = svdot_s32(vacc12, va1, vb2);\n                vacc13 = svdot_s32(vacc13, va1, vb3);\n\n                vacc20 = svdot_s32(vacc20, va2, vb0);\n                vacc21 = svdot_s32(vacc21, va2, vb1);\n                vacc22 = svdot_s32(vacc22, va2, vb2);\n                vacc23 = svdot_s32(vacc23, va2, vb3);\n\n                vacc30 = svdot_s32(vacc30, va3, vb0);\n                vacc31 = svdot_s32(vacc31, va3, vb1);\n                vacc32 = svdot_s32(vacc32, va3, vb2);\n                vacc33 = svdot_s32(vacc33, va3, vb3);\n            }\n\n            // Horizontal reduce each accumulator\n            acc00 = (int32_t)svaddv_s32(svptrue_b32(), vacc00);\n            acc01 = (int32_t)svaddv_s32(svptrue_b32(), vacc01);\n            acc02 = (int32_t)svaddv_s32(svptrue_b32(), vacc02);\n            acc03 = (int32_t)svaddv_s32(svptrue_b32(), vacc03);\n            acc10 = (int32_t)svaddv_s32(svptrue_b32(), vacc10);\n            acc11 = (int32_t)svaddv_s32(svptrue_b32(), vacc11);\n            acc12 = (int32_t)svaddv_s32(svptrue_b32(), vacc12);\n            acc13 = (int32_t)svaddv_s32(svptrue_b32(), vacc13);\n            acc20 = (int32_t)svaddv_s32(svptrue_b32(), vacc20);\n            acc21 = (int32_t)svaddv_s32(svptrue_b32(), vacc21);\n            acc22 = (int32_t)svaddv_s32(svptrue_b32(), vacc22);\n            acc23 = (int32_t)svaddv_s32(svptrue_b32(), vacc23);\n            acc30 = (int32_t)svaddv_s32(svptrue_b32(), vacc30);\n            acc31 = (int32_t)svaddv_s32(svptrue_b32(), vacc31);\n            acc32 = (int32_t)svaddv_s32(svptrue_b32(), vacc32);\n            acc33 = (int32_t)svaddv_s32(svptrue_b32(), vacc33);\n\n            // Dequantize and store\n            float s0 = input_scale * weight_scales[n+0];\n            float s1 = input_scale * weight_scales[n+1];\n            float s2 = input_scale * weight_scales[n+2];\n            float s3 = input_scale * weight_scales[n+3];\n\n            out0[n+0] = acc00 * s0; out0[n+1] = acc01 * s1; out0[n+2] = acc02 * s2; out0[n+3] = acc03 * s3;\n            out1[n+0] = acc10 * s0; out1[n+1] = acc11 * s1; out1[n+2] = acc12 * s2; out1[n+3] = acc13 * s3;\n            out2[n+0] = acc20 * s0; out2[n+1] = acc21 * s1; out2[n+2] = acc22 * s2; out2[n+3] = acc23 * s3;\n            out3[n+0] = acc30 * s0; out3[n+1] = acc31 * s1; out3[n+2] = acc32 * s2; out3[n+3] = acc33 * s3;\n        }\n\n        // Handle remaining N\n        for (; n < N; ++n) {\n            const int8_t* b0 = B + (long)n * K;\n            int32_t acc0=0, acc1=0, acc2=0, acc3=0;\n            for (int k = 0; k < K; ++k) {\n                acc0 += (int32_t)a0[k] * (int32_t)b0[k];\n                acc1 += (int32_t)a1[k] * (int32_t)b0[k];\n                acc2 += (int32_t)a2[k] * (int32_t)b0[k];\n                acc3 += (int32_t)a3[k] * (int32_t)b0[k];\n            }\n            float s = input_scale * weight_scales[n];\n            out0[n] = acc0 * s;\n            out1[n] = acc1 * s;\n            out2[n] = acc2 * s;\n            out3[n] = acc3 * s;\n        }\n    }\n\n    // Handle remaining M rows\n    for (; m < M; ++m) {\n        const int8_t* a0 = A + (long)m * K;\n        float* out0 = output + (long)m * N;\n        for (int n = 0; n < N; ++n) {\n            const int8_t* b0 = B + (long)n * K;\n            int32_t acc = 0;\n            for (int k = 0; k < K; ++k) {\n                acc += (int32_t)a0[k] * (int32_t)b0[k];\n            }\n            out0[n] = acc * (input_scale * weight_scales[n]);\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/claude-sonnet-4-6/gemm/gemm_w8a8ch_n1000_k2048.json

@@ -1,38 +0,0 @@
-{
-  "name": "claude-sonnet-4-6_gemm_w8a8ch_n1000_k2048",
-  "definition": "gemm_w8a8ch_n1000_k2048",
-  "dataset": "ncnn",
-  "author": "claude-sonnet-4-6",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [
-      "sve"
-    ],
-    "compile_flags": [
-      "-O3",
-      "-march=armv8.2-a+sve",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Per-definition constants for this gemm w8a8ch (int8) specialisation.\n// C[m, n] = (A[m,:] . B[n,:]) * (input_scale * weight_scales[n])  (no bias)\n// input_scale is a per-definition-constant dequant scalar (constant across every\n// workload — checked at generation time); weight_scales is a genuine runtime\n// per-output-channel tensor, passed as a regular float pointer below.\nnamespace gemm_def {\nconstexpr int N = 1000;\nconstexpr int K = 2048;\nconstexpr float input_scale = 0.01;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K) int8; B: (N, K) int8; weight_scales: (N) float32;\n// output: (M, N) float32.\n// Dequantization: real = int32_acc * scale, where scale = input_scale * weight_scales[n]\n// (NOT ncnn's quantization convention int8 = round(real * scale)).\nvoid inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                 const float* weight_scales, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, weight_scales*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const int8_t* A, float* output, const int8_t* B,\n                                    const float* weight_scales, int M)\n{\n    inner_gemm(A, output, B, weight_scales, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "\n#include \"gemm.h\"\n#include <arm_sve.h>\n#include <cstring>\n\nusing namespace gemm_def;\n\n// Optimized GEMM: int8 A (M x K) * int8 B (N x K) -> float32 output (M x N)\n// Strategy:\n//   - Tile over M (rows of A) and N (cols of output / rows of B)\n//   - For each tile, accumulate int32 dot products using SVE sdot\n//   - Dequantize at the end using weight_scales\n//\n// Register blocking: process 4 rows of A x 4 rows of B at a time\n// K=2048, N=1000\n\nextern \"C\" void inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                             const float* weight_scales, int M)\n{\n    // We'll use a tile of MR x NR where MR=4, NR=4\n    // For each (m_tile, n_tile), compute a 4x4 block of output\n    // using SVE sdot instructions\n\n    const int MR = 4;\n    const int NR = 4;\n\n    // Process MR rows of A at a time\n    int m = 0;\n    for (; m + MR <= M; m += MR) {\n        const int8_t* a0 = A + (long)(m+0) * K;\n        const int8_t* a1 = A + (long)(m+1) * K;\n        const int8_t* a2 = A + (long)(m+2) * K;\n        const int8_t* a3 = A + (long)(m+3) * K;\n\n        float* out0 = output + (long)(m+0) * N;\n        float* out1 = output + (long)(m+1) * N;\n        float* out2 = output + (long)(m+2) * N;\n        float* out3 = output + (long)(m+3) * N;\n\n        // Process NR rows of B at a time\n        int n = 0;\n        for (; n + NR <= N; n += NR) {\n            const int8_t* b0 = B + (long)(n+0) * K;\n            const int8_t* b1 = B + (long)(n+1) * K;\n            const int8_t* b2 = B + (long)(n+2) * K;\n            const int8_t* b3 = B + (long)(n+3) * K;\n\n            // 4x4 accumulators (int32)\n            svint32_t acc00 = svdup_s32(0);\n            svint32_t acc01 = svdup_s32(0);\n            svint32_t acc02 = svdup_s32(0);\n            svint32_t acc03 = svdup_s32(0);\n            svint32_t acc10 = svdup_s32(0);\n            svint32_t acc11 = svdup_s32(0);\n            svint32_t acc12 = svdup_s32(0);\n            svint32_t acc13 = svdup_s32(0);\n            svint32_t acc20 = svdup_s32(0);\n            svint32_t acc21 = svdup_s32(0);\n            svint32_t acc22 = svdup_s32(0);\n            svint32_t acc23 = svdup_s32(0);\n            svint32_t acc30 = svdup_s32(0);\n            svint32_t acc31 = svdup_s32(0);\n            svint32_t acc32 = svdup_s32(0);\n            svint32_t acc33 = svdup_s32(0);\n\n            // Loop over K in chunks of 4 (sdot processes 4 int8 at a time)\n            // SVE vector length is 256 bits = 32 bytes = 32 int8 elements\n            // sdot: acc[i] += a[4i]*b[4i] + a[4i+1]*b[4i+1] + a[4i+2]*b[4i+2] + a[4i+3]*b[4i+3]\n            // So each svsdot call processes vl/4 groups of 4 elements\n\n            svbool_t pg = svptrue_b8();\n            int k = 0;\n            // Process in chunks of svcntb() bytes\n            int vl = svcntb(); // number of int8 elements per vector\n\n            for (; k + vl <= K; k += vl) {\n                svint8_t va0 = svld1_s8(pg, a0 + k);\n                svint8_t va1 = svld1_s8(pg, a1 + k);\n                svint8_t va2 = svld1_s8(pg, a2 + k);\n                svint8_t va3 = svld1_s8(pg, a3 + k);\n\n                svint8_t vb0 = svld1_s8(pg, b0 + k);\n                svint8_t vb1 = svld1_s8(pg, b1 + k);\n                svint8_t vb2 = svld1_s8(pg, b2 + k);\n                svint8_t vb3 = svld1_s8(pg, b3 + k);\n\n                // Use svdot (int8 -> int32 dot product)\n                svbool_t pg32 = svptrue_b32();\n                acc00 = svdot_s32(acc00, va0, vb0);\n                acc01 = svdot_s32(acc01, va0, vb1);\n                acc02 = svdot_s32(acc02, va0, vb2);\n                acc03 = svdot_s32(acc03, va0, vb3);\n                acc10 = svdot_s32(acc10, va1, vb0);\n                acc11 = svdot_s32(acc11, va1, vb1);\n                acc12 = svdot_s32(acc12, va1, vb2);\n                acc13 = svdot_s32(acc13, va1, vb3);\n                acc20 = svdot_s32(acc20, va2, vb0);\n                acc21 = svdot_s32(acc21, va2, vb1);\n                acc22 = svdot_s32(acc22, va2, vb2);\n                acc23 = svdot_s32(acc23, va2, vb3);\n                acc30 = svdot_s32(acc30, va3, vb0);\n                acc31 = svdot_s32(acc31, va3, vb1);\n                acc32 = svdot_s32(acc32, va3, vb2);\n                acc33 = svdot_s32(acc33, va3, vb3);\n            }\n\n            // Handle remaining K elements with predicate\n            if (k < K) {\n                svbool_t pg_tail = svwhilelt_b8_s32(k, K);\n                svint8_t va0 = svld1_s8(pg_tail, a0 + k);\n                svint8_t va1 = svld1_s8(pg_tail, a1 + k);\n                svint8_t va2 = svld1_s8(pg_tail, a2 + k);\n                svint8_t va3 = svld1_s8(pg_tail, a3 + k);\n\n                svint8_t vb0 = svld1_s8(pg_tail, b0 + k);\n                svint8_t vb1 = svld1_s8(pg_tail, b1 + k);\n                svint8_t vb2 = svld1_s8(pg_tail, b2 + k);\n                svint8_t vb3 = svld1_s8(pg_tail, b3 + k);\n\n                acc00 = svdot_s32(acc00, va0, vb0);\n                acc01 = svdot_s32(acc01, va0, vb1);\n                acc02 = svdot_s32(acc02, va0, vb2);\n                acc03 = svdot_s32(acc03, va0, vb3);\n                acc10 = svdot_s32(acc10, va1, vb0);\n                acc11 = svdot_s32(acc11, va1, vb1);\n                acc12 = svdot_s32(acc12, va1, vb2);\n                acc13 = svdot_s32(acc13, va1, vb3);\n                acc20 = svdot_s32(acc20, va2, vb0);\n                acc21 = svdot_s32(acc21, va2, vb1);\n                acc22 = svdot_s32(acc22, va2, vb2);\n                acc23 = svdot_s32(acc23, va2, vb3);\n                acc30 = svdot_s32(acc30, va3, vb0);\n                acc31 = svdot_s32(acc31, va3, vb1);\n                acc32 = svdot_s32(acc32, va3, vb2);\n                acc33 = svdot_s32(acc33, va3, vb3);\n            }\n\n            // Horizontal reduce each accumulator to a scalar int32\n            svbool_t pg32 = svptrue_b32();\n            int32_t r00 = svaddv_s32(pg32, acc00);\n            int32_t r01 = svaddv_s32(pg32, acc01);\n            int32_t r02 = svaddv_s32(pg32, acc02);\n            int32_t r03 = svaddv_s32(pg32, acc03);\n            int32_t r10 = svaddv_s32(pg32, acc10);\n            int32_t r11 = svaddv_s32(pg32, acc11);\n            int32_t r12 = svaddv_s32(pg32, acc12);\n            int32_t r13 = svaddv_s32(pg32, acc13);\n            int32_t r20 = svaddv_s32(pg32, acc20);\n            int32_t r21 = svaddv_s32(pg32, acc21);\n            int32_t r22 = svaddv_s32(pg32, acc22);\n            int32_t r23 = svaddv_s32(pg32, acc23);\n            int32_t r30 = svaddv_s32(pg32, acc30);\n            int32_t r31 = svaddv_s32(pg32, acc31);\n            int32_t r32 = svaddv_s32(pg32, acc32);\n            int32_t r33 = svaddv_s32(pg32, acc33);\n\n            // Dequantize and store\n            float s0 = input_scale * weight_scales[n+0];\n            float s1 = input_scale * weight_scales[n+1];\n            float s2 = input_scale * weight_scales[n+2];\n            float s3 = input_scale * weight_scales[n+3];\n\n            out0[n+0] = (float)r00 * s0;\n            out0[n+1] = (float)r01 * s1;\n            out0[n+2] = (float)r02 * s2;\n            out0[n+3] = (float)r03 * s3;\n\n            out1[n+0] = (float)r10 * s0;\n            out1[n+1] = (float)r11 * s1;\n            out1[n+2] = (float)r12 * s2;\n            out1[n+3] = (float)r13 * s3;\n\n            out2[n+0] = (float)r20 * s0;\n            out2[n+1] = (float)r21 * s1;\n            out2[n+2] = (float)r22 * s2;\n            out2[n+3] = (float)r23 * s3;\n\n            out3[n+0] = (float)r30 * s0;\n            out3[n+1] = (float)r31 * s1;\n            out3[n+2] = (float)r32 * s2;\n            out3[n+3] = (float)r33 * s3;\n        }\n\n        // Handle remaining N\n        for (; n < N; ++n) {\n            const int8_t* b0 = B + (long)n * K;\n            svint32_t acc0 = svdup_s32(0);\n            svint32_t acc1 = svdup_s32(0);\n            svint32_t acc2 = svdup_s32(0);\n            svint32_t acc3 = svdup_s32(0);\n\n            svbool_t pg = svptrue_b8();\n            int vl = svcntb();\n            int k = 0;\n            for (; k + vl <= K; k += vl) {\n                svint8_t vb = svld1_s8(pg, b0 + k);\n                acc0 = svdot_s32(acc0, svld1_s8(pg, a0 + k), vb);\n                acc1 = svdot_s32(acc1, svld1_s8(pg, a1 + k), vb);\n                acc2 = svdot_s32(acc2, svld1_s8(pg, a2 + k), vb);\n                acc3 = svdot_s32(acc3, svld1_s8(pg, a3 + k), vb);\n            }\n            if (k < K) {\n                svbool_t pg_tail = svwhilelt_b8_s32(k, K);\n                svint8_t vb = svld1_s8(pg_tail, b0 + k);\n                acc0 = svdot_s32(acc0, svld1_s8(pg_tail, a0 + k), vb);\n                acc1 = svdot_s32(acc1, svld1_s8(pg_tail, a1 + k), vb);\n                acc2 = svdot_s32(acc2, svld1_s8(pg_tail, a2 + k), vb);\n                acc3 = svdot_s32(acc3, svld1_s8(pg_tail, a3 + k), vb);\n            }\n\n            svbool_t pg32 = svptrue_b32();\n            float s = input_scale * weight_scales[n];\n            out0[n] = (float)svaddv_s32(pg32, acc0) * s;\n            out1[n] = (float)svaddv_s32(pg32, acc1) * s;\n            out2[n] = (float)svaddv_s32(pg32, acc2) * s;\n            out3[n] = (float)svaddv_s32(pg32, acc3) * s;\n        }\n    }\n\n    // Handle remaining M rows\n    for (; m < M; ++m) {\n        const int8_t* a0 = A + (long)m * K;\n        float* out0 = output + (long)m * N;\n\n        int n = 0;\n        for (; n < N; ++n) {\n            const int8_t* b0 = B + (long)n * K;\n            svint32_t acc = svdup_s32(0);\n            svbool_t pg = svptrue_b8();\n            int vl = svcntb();\n            int k = 0;\n            for (; k + vl <= K; k += vl) {\n                acc = svdot_s32(acc, svld1_s8(pg, a0 + k), svld1_s8(pg, b0 + k));\n            }\n            if (k < K) {\n                svbool_t pg_tail = svwhilelt_b8_s32(k, K);\n                acc = svdot_s32(acc, svld1_s8(pg_tail, a0 + k), svld1_s8(pg_tail, b0 + k));\n            }\n            svbool_t pg32 = svptrue_b32();\n            float s = input_scale * weight_scales[n];\n            out0[n] = (float)svaddv_s32(pg32, acc) * s;\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/claude-sonnet-4-6/gemm/gemm_w8a8ch_n1280_k960.json

@@ -1,38 +0,0 @@
-{
-  "name": "claude-sonnet-4-6_gemm_w8a8ch_n1280_k960",
-  "definition": "gemm_w8a8ch_n1280_k960",
-  "dataset": "ncnn",
-  "author": "claude-sonnet-4-6",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [
-      "sve"
-    ],
-    "compile_flags": [
-      "-O3",
-      "-march=armv8.2-a+sve",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Per-definition constants for this gemm w8a8ch (int8) specialisation.\n// C[m, n] = (A[m,:] . B[n,:]) * (input_scale * weight_scales[n])  (no bias)\n// input_scale is a per-definition-constant dequant scalar (constant across every\n// workload — checked at generation time); weight_scales is a genuine runtime\n// per-output-channel tensor, passed as a regular float pointer below.\nnamespace gemm_def {\nconstexpr int N = 1280;\nconstexpr int K = 960;\nconstexpr float input_scale = 0.01;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K) int8; B: (N, K) int8; weight_scales: (N) float32;\n// output: (M, N) float32.\n// Dequantization: real = int32_acc * scale, where scale = input_scale * weight_scales[n]\n// (NOT ncnn's quantization convention int8 = round(real * scale)).\nvoid inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                 const float* weight_scales, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, weight_scales*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const int8_t* A, float* output, const int8_t* B,\n                                    const float* weight_scales, int M)\n{\n    inner_gemm(A, output, B, weight_scales, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "#include \"gemm.h\"\n#include <arm_sve.h>\n#include <cstring>\n#include <cstdlib>\n\nusing namespace gemm_def;\n\n// Optimized GEMM for N=1280, K=960 using SVE intrinsics\n// Strategy:\n//   - Prepack B into a packed format: groups of 4 B-rows interleaved\n//     so that for each k-chunk, we load 4 B vectors contiguously\n//   - Process 8 rows of A at a time, 4 cols of B at a time\n//   - Use sdot for int8 dot products\n//   - Avoid spilling accumulators to stack\n\n// Packed B layout: for each group of 4 n-values, store K bytes interleaved\n// B_packed[n/4][k][4] where the 4 is the n-dimension within the group\n// Actually: B_packed[n/4 * K + k * 4 + (n%4)] -- but we want contiguous k\n// Better: B_packed[n/4][k/vl][vl * 4] -- vl bytes for each of 4 n-values\n\n// For SVE with vl=32: each k-chunk of 32 bytes for 4 n-values = 128 bytes\n// B_packed[n4][k_chunk][4 * vl] where n4 = n/4, k_chunk = k/vl\n\n// Actually let's use a simpler approach: pack B so that for each n4 group,\n// we store all K bytes of b0, then all K bytes of b1, etc. (same as original)\n// but we precompute the pointers.\n\n// The key insight from the assembly: the compiler is already doing a good job\n// with the 8x4 tiling. The bottleneck is likely:\n// 1. The horizontal reduction (saddv) is expensive\n// 2. The B data access pattern causes cache misses\n\n// New approach: instead of 8 rows x 4 cols, try 4 rows x 8 cols\n// This reduces the number of saddv calls and may improve B cache reuse\n\n// Actually, let's try a different approach: pack B into a transposed format\n// where we store 4 B-rows interleaved, so we can load 4 B values at once\n// using a single vector load and then use sdot more efficiently.\n\n// For SVE with 256-bit (32 bytes per vector):\n// sdot: z_dst.s += z_a.b * z_b.b (4 int8 -> 1 int32, 8 per vector)\n// With 32-byte vectors: 8 int32 accumulators per vector\n\n// Key optimization: pack B so that 4 consecutive n-values are interleaved\n// B_packed[k][n] where n is the fast index, stored as groups of 4\n// This way, loading 4 consecutive B values for different n at same k\n// is a single vector load.\n\n// Let's try: pack B as B_packed[n/4][k][4] (4 n-values interleaved)\n// For each k position, 4 consecutive bytes are b[n+0][k], b[n+1][k], b[n+2][k], b[n+3][k]\n// Then for sdot: we need a[m][k:k+4] dot b[n][k:k+4]\n// With interleaved B, we can't directly use sdot this way.\n\n// Better: keep B as-is but improve the tiling to maximize register reuse.\n// The current 8x4 approach uses 32 accumulators (all SVE registers).\n// Let's try to improve by processing more K at once (loop unrolling).\n\n// Actually the best approach for this problem is:\n// - Pack B into a format where 4 B-rows are stored interleaved by 4 bytes\n//   (matching the sdot pattern)\n// - This allows loading 4 B-row chunks with a single load and using\n//   sdot with a broadcast of A\n\n// SVE sdot: z_dst.s += z_a.b * z_b.b\n// If we pack B as: [b0[0],b0[1],b0[2],b0[3], b1[0],b1[1],b1[2],b1[3], ...]\n// Then for a single A row, we can compute 4 dot products simultaneously\n// by loading A broadcast and B packed.\n\n// Let's implement a proper packing approach:\n// Pack B into B_packed where B_packed[n4 * K + k] contains\n// 4 bytes: b[n4*4+0][k], b[n4*4+1][k], b[n4*4+2][k], b[n4*4+3][k]\n// This way, for each k, we have 4 B values packed together.\n// Then sdot(a_broadcast, b_packed) gives 4 dot products at once.\n\n// With this packing, for a single A row:\n// acc[0:4] += sdot(a[k:k+4] broadcast, b_packed[k:k+4*4])\n// But sdot doesn't work this way directly.\n\n// Let me think differently. The standard approach for int8 GEMM:\n// Use the \"outer product\" approach where we broadcast A and multiply by B.\n// For SVE: \n//   - Load 1 A value (broadcast to all lanes)\n//   - Load 4 B values (one per n)\n//   - Multiply and accumulate\n\n// But this is scalar-like. Better to use sdot properly.\n\n// The most efficient approach for this specific problem:\n// Since K=960 and N=1280, and we're doing M rows:\n// - For each (m, n4) pair, compute 4 dot products over K=960\n// - Use sdot with 32-byte vectors: 30 iterations of 32 bytes = 960 bytes\n// - Each iteration: load 1 A vector, load 4 B vectors, do 4 sdot ops\n// - This is what v2 already does\n\n// The issue is the horizontal reduction at the end.\n// Alternative: use a different accumulation strategy where we keep\n// partial sums in a way that avoids horizontal reduction.\n\n// For the specific case of K=960 and vl=32:\n// 960/32 = 30 iterations, each producing 8 int32 partial sums per accumulator\n// After 30 iterations, we have 8 int32 values to sum -> saddv\n\n// One optimization: instead of 8 rows x 4 cols, try 4 rows x 4 cols\n// but process 2 k-chunks per iteration to better hide latency.\n\n// Let's try a completely different approach: use the fact that K=960 is fixed\n// and prepack B into a format optimized for our access pattern.\n\n// APPROACH: Pack B into B_packed[N/4][K][4] format\n// where B_packed[n4][k][j] = B[n4*4+j][k]\n// This makes B access sequential for fixed n4, varying k.\n// Then for each (m, n4), we do:\n//   for k in 0..K step 4:\n//     a_chunk = A[m][k:k+4]  (4 bytes)\n//     b_chunk = B_packed[n4][k:k+4][0:4]  (16 bytes, 4 n-values x 4 k-values)\n//     acc[0:4] += a_chunk[0]*b_chunk[0:4] + a_chunk[1]*b_chunk[4:8] + ...\n\n// This is essentially the GEMM microkernel approach.\n// With SVE sdot: we need to match the sdot semantics.\n// sdot(acc, a, b): acc[i] += sum_j(a[4i+j] * b[4i+j]) for j=0..3\n\n// For packed B where B_packed[k/4][n] = B[n][k:k+4]:\n// We want: acc[n] += sum_k(A[m][k] * B[n][k])\n// = sum_{k4} sum_{j=0}^{3} A[m][k4*4+j] * B[n][k4*4+j]\n// = sum_{k4} sdot_scalar(A[m][k4*4:k4*4+4], B[n][k4*4:k4*4+4])\n\n// With SVE sdot on 32-byte vectors (8 int32 lanes):\n// acc.s[i] += sum_j(a.b[4i+j] * b.b[4i+j])\n// So if we load A[m][k:k+32] into va and B[n][k:k+32] into vb,\n// we get 8 partial sums, one per group of 4 k-values.\n\n// The current approach is already optimal for single (m,n) pair.\n// The key is to maximize reuse across multiple (m,n) pairs.\n\n// FINAL APPROACH: Keep the 8x4 tiling but add prefetching and\n// try to improve the reduction phase.\n\n// Actually, let me try a 4x4 tiling with explicit loop unrolling\n// to see if that helps with the IPC.\n\nextern \"C\" void inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                            const float* weight_scales, int M)\n{\n    const int vl = svcntb();  // 32 for 256-bit SVE\n    svbool_t pg_b = svptrue_b8();\n    svbool_t pg_s = svptrue_b32();\n    \n    // Process 4 rows of A at a time, 4 cols of B at a time\n    // This gives 16 accumulators, leaving registers for A and B loads\n    const int mr = 4;\n    const int nr = 4;\n    \n    int m = 0;\n    for (; m + mr <= M; m += mr) {\n        const int8_t* a0 = A + (long)(m+0) * K;\n        const int8_t* a1 = A + (long)(m+1) * K;\n        const int8_t* a2 = A + (long)(m+2) * K;\n        const int8_t* a3 = A + (long)(m+3) * K;\n        \n        float* out0 = output + (long)(m+0) * N;\n        float* out1 = output + (long)(m+1) * N;\n        float* out2 = output + (long)(m+2) * N;\n        float* out3 = output + (long)(m+3) * N;\n        \n        int n = 0;\n        for (; n + nr <= N; n += nr) {\n            const int8_t* b0 = B + (long)(n+0) * K;\n            const int8_t* b1 = B + (long)(n+1) * K;\n            const int8_t* b2 = B + (long)(n+2) * K;\n            const int8_t* b3 = B + (long)(n+3) * K;\n            \n            // 4x4 accumulators\n            svint32_t vacc00 = svdup_s32(0), vacc01 = svdup_s32(0), vacc02 = svdup_s32(0), vacc03 = svdup_s32(0);\n            svint32_t vacc10 = svdup_s32(0), vacc11 = svdup_s32(0), vacc12 = svdup_s32(0), vacc13 = svdup_s32(0);\n            svint32_t vacc20 = svdup_s32(0), vacc21 = svdup_s32(0), vacc22 = svdup_s32(0), vacc23 = svdup_s32(0);\n            svint32_t vacc30 = svdup_s32(0), vacc31 = svdup_s32(0), vacc32 = svdup_s32(0), vacc33 = svdup_s32(0);\n            \n            // K=960, vl=32, so 30 iterations\n            // Unroll by 2 to hide load latency\n            int k = 0;\n            for (; k + 2*vl <= K; k += 2*vl) {\n                svint8_t va0_0 = svld1_s8(pg_b, a0 + k);\n                svint8_t va1_0 = svld1_s8(pg_b, a1 + k);\n                svint8_t va2_0 = svld1_s8(pg_b, a2 + k);\n                svint8_t va3_0 = svld1_s8(pg_b, a3 + k);\n                svint8_t vb0_0 = svld1_s8(pg_b, b0 + k);\n                svint8_t vb1_0 = svld1_s8(pg_b, b1 + k);\n                svint8_t vb2_0 = svld1_s8(pg_b, b2 + k);\n                svint8_t vb3_0 = svld1_s8(pg_b, b3 + k);\n                \n                svint8_t va0_1 = svld1_s8(pg_b, a0 + k + vl);\n                svint8_t va1_1 = svld1_s8(pg_b, a1 + k + vl);\n                svint8_t va2_1 = svld1_s8(pg_b, a2 + k + vl);\n                svint8_t va3_1 = svld1_s8(pg_b, a3 + k + vl);\n                svint8_t vb0_1 = svld1_s8(pg_b, b0 + k + vl);\n                svint8_t vb1_1 = svld1_s8(pg_b, b1 + k + vl);\n                svint8_t vb2_1 = svld1_s8(pg_b, b2 + k + vl);\n                svint8_t vb3_1 = svld1_s8(pg_b, b3 + k + vl);\n                \n                vacc00 = svdot_s32(vacc00, va0_0, vb0_0);\n                vacc01 = svdot_s32(vacc01, va0_0, vb1_0);\n                vacc02 = svdot_s32(vacc02, va0_0, vb2_0);\n                vacc03 = svdot_s32(vacc03, va0_0, vb3_0);\n                vacc10 = svdot_s32(vacc10, va1_0, vb0_0);\n                vacc11 = svdot_s32(vacc11, va1_0, vb1_0);\n                vacc12 = svdot_s32(vacc12, va1_0, vb2_0);\n                vacc13 = svdot_s32(vacc13, va1_0, vb3_0);\n                vacc20 = svdot_s32(vacc20, va2_0, vb0_0);\n                vacc21 = svdot_s32(vacc21, va2_0, vb1_0);\n                vacc22 = svdot_s32(vacc22, va2_0, vb2_0);\n                vacc23 = svdot_s32(vacc23, va2_0, vb3_0);\n                vacc30 = svdot_s32(vacc30, va3_0, vb0_0);\n                vacc31 = svdot_s32(vacc31, va3_0, vb1_0);\n                vacc32 = svdot_s32(vacc32, va3_0, vb2_0);\n                vacc33 = svdot_s32(vacc33, va3_0, vb3_0);\n                \n                vacc00 = svdot_s32(vacc00, va0_1, vb0_1);\n                vacc01 = svdot_s32(vacc01, va0_1, vb1_1);\n                vacc02 = svdot_s32(vacc02, va0_1, vb2_1);\n                vacc03 = svdot_s32(vacc03, va0_1, vb3_1);\n                vacc10 = svdot_s32(vacc10, va1_1, vb0_1);\n                vacc11 = svdot_s32(vacc11, va1_1, vb1_1);\n                vacc12 = svdot_s32(vacc12, va1_1, vb2_1);\n                vacc13 = svdot_s32(vacc13, va1_1, vb3_1);\n                vacc20 = svdot_s32(vacc20, va2_1, vb0_1);\n                vacc21 = svdot_s32(vacc21, va2_1, vb1_1);\n                vacc22 = svdot_s32(vacc22, va2_1, vb2_1);\n                vacc23 = svdot_s32(vacc23, va2_1, vb3_1);\n                vacc30 = svdot_s32(vacc30, va3_1, vb0_1);\n                vacc31 = svdot_s32(vacc31, va3_1, vb1_1);\n                vacc32 = svdot_s32(vacc32, va3_1, vb2_1);\n                vacc33 = svdot_s32(vacc33, va3_1, vb3_1);\n            }\n            for (; k + vl <= K; k += vl) {\n                svint8_t va0 = svld1_s8(pg_b, a0 + k);\n                svint8_t va1 = svld1_s8(pg_b, a1 + k);\n                svint8_t va2 = svld1_s8(pg_b, a2 + k);\n                svint8_t va3 = svld1_s8(pg_b, a3 + k);\n                svint8_t vb0 = svld1_s8(pg_b, b0 + k);\n                svint8_t vb1 = svld1_s8(pg_b, b1 + k);\n                svint8_t vb2 = svld1_s8(pg_b, b2 + k);\n                svint8_t vb3 = svld1_s8(pg_b, b3 + k);\n                \n                vacc00 = svdot_s32(vacc00, va0, vb0);\n                vacc01 = svdot_s32(vacc01, va0, vb1);\n                vacc02 = svdot_s32(vacc02, va0, vb2);\n                vacc03 = svdot_s32(vacc03, va0, vb3);\n                vacc10 = svdot_s32(vacc10, va1, vb0);\n                vacc11 = svdot_s32(vacc11, va1, vb1);\n                vacc12 = svdot_s32(vacc12, va1, vb2);\n                vacc13 = svdot_s32(vacc13, va1, vb3);\n                vacc20 = svdot_s32(vacc20, va2, vb0);\n                vacc21 = svdot_s32(vacc21, va2, vb1);\n                vacc22 = svdot_s32(vacc22, va2, vb2);\n                vacc23 = svdot_s32(vacc23, va2, vb3);\n                vacc30 = svdot_s32(vacc30, va3, vb0);\n                vacc31 = svdot_s32(vacc31, va3, vb1);\n                vacc32 = svdot_s32(vacc32, va3, vb2);\n                vacc33 = svdot_s32(vacc33, va3, vb3);\n            }\n            \n            // Horizontal reduce\n            int32_t acc00 = (int32_t)svaddv_s32(pg_s, vacc00);\n            int32_t acc01 = (int32_t)svaddv_s32(pg_s, vacc01);\n            int32_t acc02 = (int32_t)svaddv_s32(pg_s, vacc02);\n            int32_t acc03 = (int32_t)svaddv_s32(pg_s, vacc03);\n            int32_t acc10 = (int32_t)svaddv_s32(pg_s, vacc10);\n            int32_t acc11 = (int32_t)svaddv_s32(pg_s, vacc11);\n            int32_t acc12 = (int32_t)svaddv_s32(pg_s, vacc12);\n            int32_t acc13 = (int32_t)svaddv_s32(pg_s, vacc13);\n            int32_t acc20 = (int32_t)svaddv_s32(pg_s, vacc20);\n            int32_t acc21 = (int32_t)svaddv_s32(pg_s, vacc21);\n            int32_t acc22 = (int32_t)svaddv_s32(pg_s, vacc22);\n            int32_t acc23 = (int32_t)svaddv_s32(pg_s, vacc23);\n            int32_t acc30 = (int32_t)svaddv_s32(pg_s, vacc30);\n            int32_t acc31 = (int32_t)svaddv_s32(pg_s, vacc31);\n            int32_t acc32 = (int32_t)svaddv_s32(pg_s, vacc32);\n            int32_t acc33 = (int32_t)svaddv_s32(pg_s, vacc33);\n            \n            // Dequantize and store\n            float s0 = input_scale * weight_scales[n+0];\n            float s1 = input_scale * weight_scales[n+1];\n            float s2 = input_scale * weight_scales[n+2];\n            float s3 = input_scale * weight_scales[n+3];\n            \n            out0[n+0] = acc00 * s0; out0[n+1] = acc01 * s1; out0[n+2] = acc02 * s2; out0[n+3] = acc03 * s3;\n            out1[n+0] = acc10 * s0; out1[n+1] = acc11 * s1; out1[n+2] = acc12 * s2; out1[n+3] = acc13 * s3;\n            out2[n+0] = acc20 * s0; out2[n+1] = acc21 * s1; out2[n+2] = acc22 * s2; out2[n+3] = acc23 * s3;\n            out3[n+0] = acc30 * s0; out3[n+1] = acc31 * s1; out3[n+2] = acc32 * s2; out3[n+3] = acc33 * s3;\n        }\n        \n        // Handle remaining n\n        for (; n < N; ++n) {\n            const int8_t* b_row = B + (long)n * K;\n            int32_t accs[4] = {};\n            for (int k = 0; k < K; ++k) {\n                int32_t bk = (int32_t)b_row[k];\n                accs[0] += (int32_t)a0[k] * bk;\n                accs[1] += (int32_t)a1[k] * bk;\n                accs[2] += (int32_t)a2[k] * bk;\n                accs[3] += (int32_t)a3[k] * bk;\n            }\n            float s = input_scale * weight_scales[n];\n            out0[n] = accs[0] * s; out1[n] = accs[1] * s;\n            out2[n] = accs[2] * s; out3[n] = accs[3] * s;\n        }\n    }\n    \n    // Handle remaining rows (< 4)\n    for (; m < M; ++m) {\n        const int8_t* a_row = A + (long)m * K;\n        float* out_row = output + (long)m * N;\n        for (int n = 0; n < N; ++n) {\n            const int8_t* b_row = B + (long)n * K;\n            svint32_t vacc = svdup_s32(0);\n            for (int k = 0; k + vl <= K; k += vl) {\n                svint8_t va = svld1_s8(pg_b, a_row + k);\n                svint8_t vb = svld1_s8(pg_b, b_row + k);\n                vacc = svdot_s32(vacc, va, vb);\n            }\n            int32_t acc = (int32_t)svaddv_s32(pg_s, vacc);\n            out_row[n] = acc * (input_scale * weight_scales[n]);\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/reference-scalar/gemm/gemm_fp32_n1000_k1280.json

@@ -1,36 +0,0 @@
-{
-  "name": "reference-scalar_gemm_fp32_n1000_k1280",
-  "definition": "gemm_fp32_n1000_k1280",
-  "dataset": "ncnn",
-  "author": "reference-scalar",
-  "description": "Scalar raw-pointer gemm for gemm_fp32_n1000_k1280. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O2",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n\n// Per-definition constants for this gemm specialisation.\n// C[m, n] = sum_k A[m, k] * B[n, k]  (B is the [N, K] \"weight\" matrix, transposed)\nnamespace gemm_def {\nconstexpr int N = 1000;\nconstexpr int K = 1280;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K); B: (N, K); output: (M, N).\nvoid inner_gemm(const float* A, float* output, const float* B, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, int M)\n{\n    inner_gemm(A, output, B, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "// Reference-scalar gemm (fc-style: C = A @ B^T).\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const float* B, int M)\n{\n    for (int m = 0; m < M; ++m) {\n        const float* a_row = A + (long)m * K;\n        float*       out_row = output + (long)m * N;\n        for (int n = 0; n < N; ++n) {\n            const float* b_row = B + (long)n * K;\n            float sum = 0.0f;\n            for (int k = 0; k < K; ++k) {\n                sum += a_row[k] * b_row[k];\n            }\n            out_row[n] = sum;\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/reference-scalar/gemm/gemm_fp32_n1000_k2048.json

@@ -1,36 +0,0 @@
-{
-  "name": "reference-scalar_gemm_fp32_n1000_k2048",
-  "definition": "gemm_fp32_n1000_k2048",
-  "dataset": "ncnn",
-  "author": "reference-scalar",
-  "description": "Scalar raw-pointer gemm for gemm_fp32_n1000_k2048. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O2",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n\n// Per-definition constants for this gemm specialisation.\n// C[m, n] = sum_k A[m, k] * B[n, k]  (B is the [N, K] \"weight\" matrix, transposed)\nnamespace gemm_def {\nconstexpr int N = 1000;\nconstexpr int K = 2048;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K); B: (N, K); output: (M, N).\nvoid inner_gemm(const float* A, float* output, const float* B, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, int M)\n{\n    inner_gemm(A, output, B, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "// Reference-scalar gemm (fc-style: C = A @ B^T).\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const float* B, int M)\n{\n    for (int m = 0; m < M; ++m) {\n        const float* a_row = A + (long)m * K;\n        float*       out_row = output + (long)m * N;\n        for (int n = 0; n < N; ++n) {\n            const float* b_row = B + (long)n * K;\n            float sum = 0.0f;\n            for (int k = 0; k < K; ++k) {\n                sum += a_row[k] * b_row[k];\n            }\n            out_row[n] = sum;\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/reference-scalar/gemm/gemm_fp32_n1280_k960.json

@@ -1,36 +0,0 @@
-{
-  "name": "reference-scalar_gemm_fp32_n1280_k960",
-  "definition": "gemm_fp32_n1280_k960",
-  "dataset": "ncnn",
-  "author": "reference-scalar",
-  "description": "Scalar raw-pointer gemm for gemm_fp32_n1280_k960. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O2",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n\n// Per-definition constants for this gemm specialisation.\n// C[m, n] = sum_k A[m, k] * B[n, k]  (B is the [N, K] \"weight\" matrix, transposed)\nnamespace gemm_def {\nconstexpr int N = 1280;\nconstexpr int K = 960;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K); B: (N, K); output: (M, N).\nvoid inner_gemm(const float* A, float* output, const float* B, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, int M)\n{\n    inner_gemm(A, output, B, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "// Reference-scalar gemm (fc-style: C = A @ B^T).\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const float* B, int M)\n{\n    for (int m = 0; m < M; ++m) {\n        const float* a_row = A + (long)m * K;\n        float*       out_row = output + (long)m * N;\n        for (int n = 0; n < N; ++n) {\n            const float* b_row = B + (long)n * K;\n            float sum = 0.0f;\n            for (int k = 0; k < K; ++k) {\n                sum += a_row[k] * b_row[k];\n            }\n            out_row[n] = sum;\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/reference-scalar/gemm/gemm_fp32_n29_k800.json

@@ -1,36 +0,0 @@
-{
-  "name": "reference-scalar_gemm_fp32_n29_k800",
-  "definition": "gemm_fp32_n29_k800",
-  "dataset": "ncnn",
-  "author": "reference-scalar",
-  "description": "Scalar raw-pointer gemm for gemm_fp32_n29_k800. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O2",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n\n// Per-definition constants for this gemm specialisation.\n// C[m, n] = sum_k A[m, k] * B[n, k]  (B is the [N, K] \"weight\" matrix, transposed)\nnamespace gemm_def {\nconstexpr int N = 29;\nconstexpr int K = 800;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K); B: (N, K); output: (M, N).\nvoid inner_gemm(const float* A, float* output, const float* B, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const float* A, float* output, const float* B, int M)\n{\n    inner_gemm(A, output, B, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "// Reference-scalar gemm (fc-style: C = A @ B^T).\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const float* A, float* output, const float* B, int M)\n{\n    for (int m = 0; m < M; ++m) {\n        const float* a_row = A + (long)m * K;\n        float*       out_row = output + (long)m * N;\n        for (int n = 0; n < N; ++n) {\n            const float* b_row = B + (long)n * K;\n            float sum = 0.0f;\n            for (int k = 0; k < K; ++k) {\n                sum += a_row[k] * b_row[k];\n            }\n            out_row[n] = sum;\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/reference-scalar/gemm/gemm_w8a8ch_n1000_k1280.json

@@ -1,36 +0,0 @@
-{
-  "name": "reference-scalar_gemm_w8a8ch_n1000_k1280",
-  "definition": "gemm_w8a8ch_n1000_k1280",
-  "dataset": "ncnn",
-  "author": "reference-scalar",
-  "description": "Scalar raw-pointer gemm for gemm_w8a8ch_n1000_k1280. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O2",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Per-definition constants for this gemm w8a8ch (int8) specialisation.\n// C[m, n] = (A[m,:] . B[n,:]) * (input_scale * weight_scales[n])  (no bias)\n// input_scale is a per-definition-constant dequant scalar (constant across every\n// workload \u2014 checked at generation time); weight_scales is a genuine runtime\n// per-output-channel tensor, passed as a regular float pointer below.\nnamespace gemm_def {\nconstexpr int N = 1000;\nconstexpr int K = 1280;\nconstexpr float input_scale = 0.01;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K) int8; B: (N, K) int8; weight_scales: (N) float32;\n// output: (M, N) float32.\n// Dequantization: real = int32_acc * scale, where scale = input_scale * weight_scales[n]\n// (NOT ncnn's quantization convention int8 = round(real * scale)).\nvoid inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                 const float* weight_scales, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, weight_scales*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const int8_t* A, float* output, const int8_t* B,\n                                    const float* weight_scales, int M)\n{\n    inner_gemm(A, output, B, weight_scales, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "// Reference-scalar gemm w8a8ch (int8 activations + weights, per-output-channel dequant, no bias).\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                            const float* weight_scales, int M)\n{\n    for (int m = 0; m < M; ++m) {\n        const int8_t* a_row   = A + (long)m * K;\n        float*        out_row = output + (long)m * N;\n        for (int n = 0; n < N; ++n) {\n            const int8_t* b_row = B + (long)n * K;\n            int64_t acc = 0;\n            for (int k = 0; k < K; ++k) {\n                acc += (int64_t)a_row[k] * (int64_t)b_row[k];\n            }\n            double scale = (double)input_scale * (double)weight_scales[n];\n            out_row[n] = (float)((double)acc * scale);\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/reference-scalar/gemm/gemm_w8a8ch_n1000_k2048.json

@@ -1,36 +0,0 @@
-{
-  "name": "reference-scalar_gemm_w8a8ch_n1000_k2048",
-  "definition": "gemm_w8a8ch_n1000_k2048",
-  "dataset": "ncnn",
-  "author": "reference-scalar",
-  "description": "Scalar raw-pointer gemm for gemm_w8a8ch_n1000_k2048. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O2",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Per-definition constants for this gemm w8a8ch (int8) specialisation.\n// C[m, n] = (A[m,:] . B[n,:]) * (input_scale * weight_scales[n])  (no bias)\n// input_scale is a per-definition-constant dequant scalar (constant across every\n// workload \u2014 checked at generation time); weight_scales is a genuine runtime\n// per-output-channel tensor, passed as a regular float pointer below.\nnamespace gemm_def {\nconstexpr int N = 1000;\nconstexpr int K = 2048;\nconstexpr float input_scale = 0.01;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K) int8; B: (N, K) int8; weight_scales: (N) float32;\n// output: (M, N) float32.\n// Dequantization: real = int32_acc * scale, where scale = input_scale * weight_scales[n]\n// (NOT ncnn's quantization convention int8 = round(real * scale)).\nvoid inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                 const float* weight_scales, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, weight_scales*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const int8_t* A, float* output, const int8_t* B,\n                                    const float* weight_scales, int M)\n{\n    inner_gemm(A, output, B, weight_scales, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "// Reference-scalar gemm w8a8ch (int8 activations + weights, per-output-channel dequant, no bias).\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                            const float* weight_scales, int M)\n{\n    for (int m = 0; m < M; ++m) {\n        const int8_t* a_row   = A + (long)m * K;\n        float*        out_row = output + (long)m * N;\n        for (int n = 0; n < N; ++n) {\n            const int8_t* b_row = B + (long)n * K;\n            int64_t acc = 0;\n            for (int k = 0; k < K; ++k) {\n                acc += (int64_t)a_row[k] * (int64_t)b_row[k];\n            }\n            double scale = (double)input_scale * (double)weight_scales[n];\n            out_row[n] = (float)((double)acc * scale);\n        }\n    }\n}\n"
-    }
-  ]
-}

solutions/ncnn/reference-scalar/gemm/gemm_w8a8ch_n1280_k960.json

@@ -1,36 +0,0 @@
-{
-  "name": "reference-scalar_gemm_w8a8ch_n1280_k960",
-  "definition": "gemm_w8a8ch_n1280_k960",
-  "dataset": "ncnn",
-  "author": "reference-scalar",
-  "description": "Scalar raw-pointer gemm for gemm_w8a8ch_n1280_k960. Constexpr-baked dims; armbench_entry_gemm calls inner_gemm. Ground-truth correctness baseline.",
-  "spec": {
-    "language": "cpp",
-    "target_hardware": [
-      "graviton3",
-      "aarch64-sve"
-    ],
-    "entry_point": "gemm.cpp::armbench_entry_gemm",
-    "dependencies": [],
-    "isa_features": [],
-    "compile_flags": [
-      "-O2",
-      "-std=c++14"
-    ],
-    "link_flags": []
-  },
-  "sources": [
-    {
-      "path": "gemm.h",
-      "content": "#pragma once\n#include <cstdint>\n\n// Per-definition constants for this gemm w8a8ch (int8) specialisation.\n// C[m, n] = (A[m,:] . B[n,:]) * (input_scale * weight_scales[n])  (no bias)\n// input_scale is a per-definition-constant dequant scalar (constant across every\n// workload \u2014 checked at generation time); weight_scales is a genuine runtime\n// per-output-channel tensor, passed as a regular float pointer below.\nnamespace gemm_def {\nconstexpr int N = 1280;\nconstexpr int K = 960;\nconstexpr float input_scale = 0.01;\n} // namespace gemm_def\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n// LLM target: implement this in kernel.cpp.\n// M is the only var dim. A: (M, K) int8; B: (N, K) int8; weight_scales: (N) float32;\n// output: (M, N) float32.\n// Dequantization: real = int32_acc * scale, where scale = input_scale * weight_scales[n]\n// (NOT ncnn's quantization convention int8 = round(real * scale)).\nvoid inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                 const float* weight_scales, int M);\n#ifdef __cplusplus\n}\n#endif\n"
-    },
-    {
-      "path": "gemm.cpp",
-      "content": "// Binding harness: forwards straight to inner_gemm (no derived dims needed).\n// ABI: armbench_entry_gemm(A*, output*, B*, weight_scales*, M)\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" int armbench_entry_gemm(const int8_t* A, float* output, const int8_t* B,\n                                    const float* weight_scales, int M)\n{\n    inner_gemm(A, output, B, weight_scales, M);\n    return 0;\n}\n"
-    },
-    {
-      "path": "kernel.cpp",
-      "content": "// Reference-scalar gemm w8a8ch (int8 activations + weights, per-output-channel dequant, no bias).\n// LLM target: replace this file with an optimised inner_gemm.\n// All per-definition constants live in gemm_def:: (gemm.h).\n#include \"gemm.h\"\nusing namespace gemm_def;\n\nextern \"C\" void inner_gemm(const int8_t* A, float* output, const int8_t* B,\n                            const float* weight_scales, int M)\n{\n    for (int m = 0; m < M; ++m) {\n        const int8_t* a_row   = A + (long)m * K;\n        float*        out_row = output + (long)m * N;\n        for (int n = 0; n < N; ++n) {\n            const int8_t* b_row = B + (long)n * K;\n            int64_t acc = 0;\n            for (int k = 0; k < K; ++k) {\n                acc += (int64_t)a_row[k] * (int64_t)b_row[k];\n            }\n            double scale = (double)input_scale * (double)weight_scales[n];\n            out_row[n] = (float)((double)acc * scale);\n        }\n    }\n}\n"
-    }
-  ]
-}

workloads/gemm/gemm_fp32_n1000_k1280.jsonl

@@ -1,24 +0,0 @@
-{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "de01d98227635a4ba08a8379123c536f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 6}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "2fb420ac05665431a8de926274d21afb", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 9}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "5c4cce984e025302acb309ca205fe596", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 12}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "76e40ade4c5153699739d4dbe7b04e1a", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 13}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "9d6ba463bc2b5bcca7aaf7f700902c1c", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 14}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "738972c30a175b9a97a43824c2c395b7", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 15}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "8358f95184835ef1857329271a7a4bd5", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 16}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "3300a1cbb0b054feb60b3ac6495e5782", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 17}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "4655f4c22882543e9349d6382693f78b", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 18}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "3a4bbefa4e7852b09c0a12ba1bbe6a93", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 19}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "a48c30c2dde05651a669fa350991f8fc", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 20}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "f85c0ab757555610bf365e8cde083eca", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 21}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "f22f7ecd7c3850b890bc33ff6b809ed7", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 22}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "4c2cd23804b85f28bacfe9116fb3ec11", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 23}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "a006a1c668da5e958cbb3c1a32ccc8ad", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 24}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "79bb1460489850ae96b0480f5ea48d2d", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 25}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "6e3b07baeae3586b838ed1c5cd6332d2", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 26}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "d9dc44cfd4245113aaceacb6153204cc", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 27}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "2d4ac949c4f457e4851141933ea16279", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 28}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "0cf6a462dac85021a7a06a5bfb99a44a", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 11}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "2f931763b6dd565c891a795450cc896c", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 29}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "9761c93864295655b572e61327568b0d", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 30}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "324ce7d729a75f02a95eeda1cc5a63cb", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 31}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "82b2ce8f9a7c52b2861888d2827ca8b4", "tags": {"from": "gen_workload"}}

workloads/gemm/gemm_fp32_n1000_k2048.jsonl

@@ -1,24 +0,0 @@
-{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "2a08791980ea5f8cb14059b7f2ef86d2", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 6}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "16fad6101426547da9a7aba891d2a943", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 9}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "f1f0f342ad045ad187186a0dad8c0f97", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 12}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "f0f70618c9875b5f924828a6e99e0b55", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 13}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "4df5fb5ed1925754998d55aa45965bfd", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 14}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "dc80645dd1e357699bd399cb1261a018", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 15}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "623bed3ff1cd5ad29b2eaf0387cd3d28", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 16}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "b78377247ac35f018c50754cf5b2d26b", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 17}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "658cde8d5f43527d9c3eddbf3ae9435e", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 18}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "d1a76bbf5ffe56efab7d409fd175b87a", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 19}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "9d29a6a1f84b581fb0bfdde2b7d4995f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 20}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "62ff30174a025bc0ad4eff3c140bdaf6", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 21}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "07054c470ef35e11bd7a44d72763fabd", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 22}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "703a76f23d0e5f489de799ec88420bde", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 23}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "4d6a428baf9b5a179bbd82ecf642fe8e", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 24}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "56d3ee607330542190a3f5ab0f58975f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 25}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "4e316a48931357759ded2b75c76e90ce", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 26}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "8643b81d91d953089c5dcaa9e256eac9", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 27}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "7c86b07095805ee3986754e9678371be", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 28}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "95c8b7673cd65c4bac64441f15f5b109", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 11}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "abc54da5dc4d5e8c91a2996ef979985f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 29}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "bbf2e62c624a5e449b6f48386ca009fe", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 30}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "34f1cd14e1b656b99489b90c7a9cdf0c", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 31}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "4a4da2b0b8c85a8ea70723c65e59cd0e", "tags": {"from": "gen_workload"}}

workloads/gemm/gemm_fp32_n1280_k960.jsonl

@@ -1,24 +0,0 @@
-{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "941f1df205c1540ebdc1b8c057b67ba9", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 6}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "dc604721cb2751f1a9e49b2c7b23b5a4", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 9}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "3fc9edc2eda85c56863e074774dc7f0c", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 12}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "840f1a59eb33529c93ee8b68910218eb", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 13}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "7e1f8747e4a25ca6bacdc7898788d239", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 14}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "247cbc9c58f2514a8bf4e01e258fd1bf", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 15}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "91b1937b662f5c9fae4c7f0d66aa370f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 16}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "074d19570f025588bbe0e2849505f7f2", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 17}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "df1d6f4a189b54818f561f10cf1d3348", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 18}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "ea542371b0fc5ed6899442536c4812c4", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 19}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "1289794a5b7b5724b8a4624aabc623ba", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 20}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "778ccfcfed2a5e1bb066d9c863ef863c", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 21}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "4e1b709b25fa5749bf85fe770d5f7f15", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 22}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "90a2c696ace958e2b88335ea4aa38ea0", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 23}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "0b9534c90f2858a984e19a9025addb57", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 24}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "59b77546a84d56e7aea61af3de6b8d10", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 25}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "abca8c40b99154879194e094298b1f3c", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 26}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "555b29c5338d57c48ba7f9392e9f1641", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 27}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "3bb4f806db3d5198aecceecf84b6b8de", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 28}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "8817093554745a849572f78ce91a8ee1", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 11}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "ecda99b1d35650379618071b10f5894a", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 29}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "ff596c4ff63d56e08a9186b0837e88b0", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 30}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "c53df7903dfb5c95a0e27a14b3f5e78d", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 31}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "20e8d6464ef55509becdcbe8f1bd376d", "tags": {"from": "gen_workload"}}

workloads/gemm/gemm_fp32_n29_k800.jsonl

@@ -1,24 +0,0 @@
-{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "80a3717872505d0d99dc592438107e84", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 6}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "89d749050f1f50ca81266998f769f53c", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 9}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "6a3411d5dfe150acafb113e8450ebb48", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 12}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "21823d329df759b09d128543d10774f5", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 13}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "bbb07ede79b65b848f498af147469cc2", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 14}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "697686780cc85161af2289230ccb3365", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 15}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "b42e0d92e5225ea29a1935c70d7fd7cc", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 16}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "9778607f51c75eb892ce2f7098f6f3fb", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 17}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "84083fa506bd5f8a91a8ef05da1687af", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 18}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "3db212a9964c58c1a1e3fa758a6c0731", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 19}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "daf73531d62b52aebb483535728545de", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 20}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "45e0d943deaf5a0183487608dfc225d1", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 21}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "4a9e2245581f5099a084a066e510be2f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 22}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "3d6348ad864051b49cd39ca4a2cce386", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 23}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "69dc8ee2a776564ca57526270e6d2eaf", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 24}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "62d6e3f36ff654ab83f3fd9cb0e91ddf", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 25}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "0fd59d13c4d55309a49c8ba65ad4db69", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 26}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "e652977a179e5c58b58963c0c712d02a", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 27}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "25aed694b0285c7c8d75b8bbe667db1c", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 28}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "98555ef366365651859bd1c037e49a59", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 11}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "3977add35fd85f3caedaa8c61cd9bae4", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 29}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "308a8efb3a42504783b452231ace134f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 30}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "6de9814af98c5287b8fb050b52596818", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 31}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}}, "uuid": "41e7637e909f5c35b62fb9574c8f0435", "tags": {"from": "gen_workload"}}

workloads/gemm/gemm_w8a8ch_n1000_k1280.jsonl

@@ -1,24 +0,0 @@
-{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "734d948499c851639dda8ebd7b083318", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 6}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "b2bf2f304a775fa4b478f173c72e2e29", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 9}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "98276059efe959c19cbcc020fba974e7", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 12}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "bd9d9024ee5850a7b041e54155e7ddb6", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 13}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "ebef01836e0c508f8d1c76b4ac699bb7", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 14}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "d060c860896d5290891e0287b3c4123b", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 15}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "a12b62901fdc518ea2781287b42b4bcb", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 16}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "9b0f77450363552d8c1be896e6472f1a", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 17}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "df000ded665554d9bfba8ba5ae619ba1", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 18}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "e2b31e73c0d35a5b9f9677c6f15af081", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 19}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "85879015803f50e488ab6aca7887ac07", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 20}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "d34ffbe36f95593b9ae9f36daf5429c4", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 21}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "b31f6cfff24f5a4185cc23d312c64598", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 22}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "38932e2f2c2d555b895eed92a7efc1b7", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 23}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "18b901025e85545daba873bebf094bab", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 24}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "0110124b1cd6524cb3072ae0c9e729c2", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 25}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "9a5c994de8f55daa97c09373cacfeacb", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 26}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "1f14e4cac9995650ad270980f0d12418", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 27}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "68ff82cd739e556e8fcf46ab928940e1", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 28}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "433529d39a9b5672a9f2c1105606f6b0", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 11}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "3b140127cbed57b798cc0c0ffb488129", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 29}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "44bc10cd591f5696b3a407c9a349823a", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 30}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "5c9e7463841156e288508483178993b3", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 31}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "02b6ccca1ed153dab7735492f3fdf082", "tags": {"from": "gen_workload"}}

workloads/gemm/gemm_w8a8ch_n1000_k2048.jsonl

@@ -1,24 +0,0 @@
-{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "c56ef851c7775a458becac2178e541fa", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 6}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "967dc61bb37c51dba200c8179bab3ec6", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 9}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "06cf7fd57cc15cfbb95e5a46dafd29a5", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 12}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "4c7263c7582a5f43afcf44d20a873f80", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 13}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "93fcb154b64452fb9b83497094379d6f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 14}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "587b1ef0ba785852bf9e1b3d9bbe67b4", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 15}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "5650eb3754a75d468199f1e6fe0cb723", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 16}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "a20e501ca72b56bc9febf3e5bee7a673", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 17}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "213031a051635f1e8a9705588c80d333", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 18}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "acee3672b8c45ff690f8e3326b593566", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 19}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "16781f2a48e75e2baf2fbe98b92d033f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 20}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "023967a15a6e5b10b5982ae6c63e3a8d", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 21}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "cf423afb4b145886bfc741a83d8b9038", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 22}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "841c7c411c775f43bcbb152f21cb7478", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 23}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "fe52154fcf0654d68dce96a61d1a6101", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 24}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "110669b0309856e9954277560d2803af", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 25}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "80653e0b69cc56e1a1acb224d244e772", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 26}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "32bc55585594512ba38afb6010ca7c2c", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 27}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "6db4974472315ee687a27ce751ab43c1", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 28}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "f24e397998855d468283cf9cc01d1de1", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 11}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "43bc5f4105fb5e5cad2e01e9bd56cf85", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 29}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "4649ddf61a6e5fffb41b5a9f99e2efbd", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 30}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "3fd8339e53915966ae9f22ed15b5fe07", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 31}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "c49505a61f195f349e9edfd12c6982a8", "tags": {"from": "gen_workload"}}

workloads/gemm/gemm_w8a8ch_n1280_k960.jsonl

@@ -1,24 +0,0 @@
-{"axes": {"M": 1}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "585ba5dcd85053b0a62669b09c316a83", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 6}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "3d8c11b1dc2956f9a865c25e78d482cc", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 9}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "c8ee2a773b59514a8a40418ec190da04", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 12}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "7c558ab4584f5900a8b58898179d0286", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 13}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "ef4559f3b11454bba31c498ff0bc75d4", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 14}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "c0e1833e7c11587ab8fec52ec73adb09", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 15}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "f345e2f008a1559f97b585006f1437cf", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 16}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "ad42a1b370a6526295844c45a78f7c99", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 17}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "1c7b865b8e7d56398ba4e6a023e7bd3b", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 18}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "343adfb486d6569c97a02245a0353147", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 19}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "9a589b9cf2bc583aa5cdc3c69be78387", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 20}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "c82db9db6d7f57dabd3d7bc047a1d088", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 21}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "74d569f336935c40b84e9e3bfb14b1dc", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 22}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "920449037b865575a23369799a55f889", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 23}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "76da3887b24a58ca958b4fc358a2427f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 24}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "9481d89858695a49b1313fdbef3c3571", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 25}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "be801ce24bba5c4790f8cbeb68f13cc3", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 26}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "9310cec9ecaf57588f6f64eef89be40f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 27}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "c51ce0386a1e5d029a8d1212daae81c0", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 28}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "09e6e4f8dce95ab5aa519098fa594b1f", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 11}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "19bdce7ddcea585cae1aef5dcd7422ba", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 29}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "5d7b2b16bad255f2864d4a091fbfd5ce", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 30}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "25ef576b517953569538a799d0a4af46", "tags": {"from": "gen_workload"}}
-{"axes": {"M": 31}, "inputs": {"A": {"type": "random"}, "B": {"type": "random"}, "input_scale": {"type": "scalar", "value": 0.01}, "weight_scales": {"type": "random"}}, "uuid": "24653fa265f85756a23d95c468c37207", "tags": {"from": "gen_workload"}}